home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_glimpse.idb / usr / freeware / src / glimpse-3.0 / agrep / agrep.c.z / agrep.c
C/C++ Source or Header  |  1997-09-09  |  103KB  |  3,445 lines
  1.  
  2. /*
  3.  * bgopal: (1993-4) added a library interface and removed some bugs: also
  4.  * selectively modified many routines to work with our text-compression algo.
  5.  */
  6. #include "agrep.h"
  7. #include "checkfile.h"
  8.  
  9. #define PRINT(s)
  10.  
  11. extern char **environ;
  12. extern int errno;
  13. int pattern_index;    /* index in argv where the pattern is */
  14.  
  15. int glimpse_isserver=0;    /* so that there is no user interaction */
  16. int glimpse_call = 0;    /* So that usage message is not printed twice */
  17. int glimpse_clientdied=0;/* to quit search if glimpseserver's client dies */
  18. int  agrep_initialfd;    /* Where does input come from? File/Memory? */
  19. CHAR *agrep_inbuffer;
  20. int  agrep_inlen;
  21. int  agrep_inpointer;
  22.  
  23. FILE *agrep_finalfp;    /* Where does output go to? File/Memory? */
  24. CHAR *agrep_outbuffer;
  25. int  agrep_outlen;
  26. int  agrep_outpointer;
  27.  
  28. int  execfd;    /* used by exec called within agrep_search, set in agrep_init */
  29. int  multifd = -1; /* fd for multipattern search used in ^^ , set in   ^^^^^^^^ */
  30. extern char *pat_spool;
  31. #if    DOTCOMPRESSED
  32. extern char *tc_pat_spool;
  33. #endif    /* DOTCOMPRESSED */
  34. char *multibuf=NULL; /* buffer to put the multiple patterns in */
  35. int  multilen = 0; /* length of the multibuf: not the #of multi-patterns! */
  36.  
  37. extern int pos_cnt;    /* to re-initialize it to 0 for reg-exp search */
  38. unsigned Mask[MAXSYM];
  39. unsigned Init1, NO_ERR_MASK, Init[MaxError];
  40. unsigned Bit[WORD+1];
  41. CHAR buffer[BlockSize+Maxline+1];    /* should not be used anywhere: 10/18/93 */
  42. unsigned Next[MaxNext], Next1[MaxNext];
  43. unsigned wildmask, endposition, D_endpos; 
  44. int  LIMITOUTPUT;    /* maximum number of matches we are going to allow */
  45. int  LIMITPERFILE;    /* maximum number of matches per file we are going to allow */
  46. int  LIMITTOTALFILE;    /* maximum number of files we are going to allow */
  47. int  EXITONERROR;    /* return -1 or exit on error? */
  48. int  REGEX, FASTREGEX, RE_ERR, FNAME, WHOLELINE, SIMPLEPATTERN;
  49. int  COUNT, HEAD, TAIL, LINENUM, INVERSE, I, S, DD, AND, SGREP, JUMP; 
  50. int  NOOUTPUTZERO;
  51. int  Num_Pat, PSIZE, prev_num_of_matched, num_of_matched, files_matched, SILENT, NOPROMPT, BESTMATCH, NOUPPER;
  52. int  NOMATCH, TRUNCATE, FIRST_IN_RE, FIRSTOUTPUT;
  53. int  WORDBOUND, DELIMITER, D_length, tc_D_length, original_D_length;
  54. int  EATFIRST, OUTTAIL;
  55. int  BYTECOUNT;
  56. int  PRINTOFFSET;
  57. int  PRINTRECORD;
  58. int  FILEOUT;
  59. int  DNA;
  60. int  APPROX;
  61. int  PAT_FILE;    /* multiple patterns from a given file */
  62. char PAT_FILE_NAME[MAX_LINE_LEN];
  63. int  PAT_BUFFER; /* multiple patterns from a given buffer */
  64. int  CONSTANT;
  65. int  RECURSIVE;
  66. int  total_line; /* used in mgrep */
  67. int  D;
  68. int  M;
  69. int  TCOMPRESSED;
  70. int  EASYSEARCH;    /* 1 used only for compressed files: LITTLE/BIG */
  71. int  ALWAYSFILENAME = OFF;
  72. int  POST_FILTER = OFF;
  73. int  NEW_FILE = OFF;    /* only when post-filter is used */
  74. int  PRINTFILENUMBER = OFF;
  75. int  PRINTPATTERN = OFF;
  76. int  MULTI_OUTPUT = OFF; /* should mgrep print the matched line multiple times for each matched pattern or just once? */
  77. /* invisible to the user, used only by glimpse: cannot use -l since it is incompatible with stdin and -A is used for the index search (done next) */
  78.  
  79. /* Stuff to handle complicated boolean patterns */
  80. int  AComplexBoolean = 0;
  81. ParseTree *AParse = NULL;
  82. int anum_terminals = 0;
  83. ParseTree aterminals[MAXNUM_PAT];
  84. char amatched_terminals[MAXNUM_PAT];
  85.  
  86. #if    MEASURE_TIMES
  87. /* timing variables */
  88. int OUTFILTER_ms;
  89. int FILTERALGO_ms;
  90. int INFILTER_ms;
  91. #endif    /*MEASURE_TIMES*/
  92.  
  93. CHAR **Textfiles = NULL;     /* array of filenames to be searched */
  94. int Numfiles = 0;    /* indicates how many files in Textfiles */
  95. int copied_from_argv = 0; /* were filenames copied from argv (should I free 'em)? */
  96. CHAR old_D_pat[MaxDelimit * 2] = "\n";  /* to hold original D_pattern */
  97. CHAR original_old_D_pat[MaxDelimit * 2] = "\n";
  98. CHAR Pattern[MAXPAT], OldPattern[MAXPAT];
  99. CHAR CurrentFileName[MAX_LINE_LEN];
  100. int SetCurrentFileName = 0;    /* dirty glimpse trick to make filters work: output seems to come from another file */
  101. int CurrentByteOffset;
  102. int SetCurrentByteOffset = 0;
  103. CHAR Progname[MAXNAME]; 
  104. CHAR D_pattern[MaxDelimit * 2] = "\n; "; /* string which delimits records -- defaults to newline */
  105. CHAR tc_D_pattern[MaxDelimit * 2] = "\n";
  106. CHAR original_D_pattern[MaxDelimit * 2] = "\n; ";
  107. char COMP_DIR[MAX_LINE_LEN];
  108. char FREQ_FILE[MAX_LINE_LEN], HASH_FILE[MAX_LINE_LEN], STRING_FILE[MAX_LINE_LEN];    /* interfacing with tcompress */
  109.  
  110. int  NOFILENAME,  /* Boolean flag, set for -h option */
  111.      FILENAMEONLY;/* Boolean flag, set for -l option */
  112. extern int init();
  113. int table[WORD][WORD];
  114. CHAR *agrep_saved_pattern = NULL;    /* to prevent multiple prepfs for each boolean search: crd@hplb.hpl.hp.com */
  115.  
  116. /* Called when multipattern search and pattern has not changed */
  117. void
  118. reinit_value_partial()
  119. {
  120.     num_of_matched = prev_num_of_matched = 0;
  121.     errno = 0;
  122.     FIRST_IN_RE = ON;
  123. }
  124.  
  125. /* This must be called before every agrep_search to reset agrep globals */
  126. void
  127. reinit_value()
  128. {
  129.         int i, j;
  130.  
  131.     /* Added on 7th Oct 194 */
  132.     if (AParse) {
  133.         if (AComplexBoolean) destroy_tree(AParse);
  134.         AComplexBoolean = 0;
  135.         AParse = 0;
  136.         PAT_BUFFER = 0;
  137.         if (multibuf != NULL) free(multibuf);    /* this was allocated for arbit booleans, not multipattern search */
  138.         multibuf = NULL;
  139.         multilen = 0;
  140.         /* Cannot free multifd here since that is always allocated for multipattern search */
  141.     }
  142.     for (i=0; i<anum_terminals; i++) {
  143.         free(aterminals[i].data.leaf.value);
  144.         memset(&aterminals[i], '\0', sizeof(ParseTree));
  145.     }
  146.     anum_terminals = 0;
  147.  
  148.         Bit[WORD] = 1;
  149.         for (i = WORD - 1; i > 0  ; i--)  Bit[i] = Bit[i+1] << 1;
  150.         for (i=0; i< MAXSYM; i++) Mask[i] = 0;
  151.  
  152.         /* bg: new things added on Mar 13 94 */
  153.         Init1 = 0;
  154.         NO_ERR_MASK = 0;
  155.         memset(Init, '\0', MaxError * sizeof(unsigned));
  156.         memset(Next, '\0', MaxNext * sizeof(unsigned));
  157.         memset(Next1, '\0', MaxNext * sizeof(unsigned));
  158.         wildmask = endposition = D_endpos = 0;
  159.         for (i=0; i<WORD; i++)
  160.                 for (j=0; j<WORD; j++)
  161.                         table[i][j] = 0;
  162.  
  163.         strcpy(D_pattern, original_D_pattern);
  164.         D_length = original_D_length;
  165.         strcpy(old_D_pat, original_old_D_pat);
  166.  
  167.     /* Changed on Dec 26th: bg */
  168.     FASTREGEX = REGEX = 0;
  169.     HEAD = TAIL = ON;    /* were off initially */
  170.     RE_ERR = 0;
  171.     AND = 0;
  172.     M = 0;
  173.     pos_cnt = 0;    /* added 31 Jan 95 */
  174.  
  175.     reinit_value_partial();
  176. }
  177.  
  178. /* This must be called before every agrep_init to reset agrep options */
  179. void
  180. initial_value()
  181. {
  182.     SetCurrentFileName = 0;    /* 16/9/94 */
  183.     SetCurrentByteOffset = 0;    /* 23/9/94 */
  184.  
  185.     /* courtesy: crd@hplb.hpl.hp.com */
  186.     if (agrep_saved_pattern) {
  187.         free(agrep_saved_pattern);
  188.         agrep_saved_pattern= NULL;
  189.     }
  190.     /* bg: new stuff on 17/Feb/94 */
  191.     if (multifd != -1) close(multifd);
  192.     multifd = -1;
  193.     if (multibuf != NULL) free(multibuf);
  194.     multibuf = NULL;
  195.     multilen = 0;
  196.     if (pat_spool != NULL) free(pat_spool);
  197.     pat_spool = NULL;
  198. #if    DOTCOMPRESSED
  199.     if (tc_pat_spool != NULL) free(tc_pat_spool);
  200.     tc_pat_spool = NULL;
  201. #endif    /* DOTCOMPRESSED */
  202.     LIMITOUTPUT = 0;    /* means infinity = current semantics */
  203.     LIMITPERFILE = 0;    /* means infinity = current semantics */
  204.     LIMITTOTALFILE = 0;    /* means infinity = current semantics */
  205.     EASYSEARCH = 1;
  206.     DNA = APPROX = PAT_FILE = PAT_BUFFER = CONSTANT = total_line = D = TCOMPRESSED = 0;
  207.     PAT_FILE_NAME[0] = '\0';
  208.     EXITONERROR = NOFILENAME = FILENAMEONLY = FILEOUT = ALWAYSFILENAME = NEW_FILE = POST_FILTER = 0;
  209.  
  210.         original_old_D_pat[0] = old_D_pat[0] = '\n';
  211.         original_old_D_pat[1] = old_D_pat[1] = '\0';
  212.         original_D_pattern[0] = D_pattern[0] = '\n';
  213.         original_D_pattern[1] = D_pattern[1] = ';';
  214.         original_D_pattern[2] = D_pattern[2] = ' ';
  215.         original_D_pattern[3] = D_pattern[3] = '\0';
  216.  
  217.     strcpy(tc_D_pattern, "\n");
  218.     tc_D_length = 1;
  219.  
  220.     /* the functions agrep_init and agrep_search take care of Textfiles and Numfiles */
  221.     agrep_inpointer = 0;
  222.     agrep_outpointer = 0;
  223.     agrep_outlen = 0;
  224. #if    MEASURE_TIMES
  225.     OUTFILTER_ms = FILTERALGO_ms = INFILTER_ms = 0;
  226. #endif    /*MEASURE_TIMES*/
  227.  
  228.     MULTI_OUTPUT = 0;
  229.     PRINTPATTERN = 0;
  230.     PRINTFILENUMBER = 0;
  231.     JUMP = FNAME = BESTMATCH = NOPROMPT = NOUPPER = 0;
  232.     RECURSIVE = 0;
  233.     COUNT = LINENUM = WHOLELINE = SGREP = 0;
  234.     NOOUTPUTZERO = 0;
  235.     EATFIRST = INVERSE = TRUNCATE = OUTTAIL = 0; 
  236.     NOMATCH = FIRSTOUTPUT = ON;    /* were off initally */
  237.     I = DD = S = 1;    /* were off initially */
  238.     original_D_length = D_length = 2;    /* was 0 initially */
  239.     SILENT = Num_Pat = PSIZE = SIMPLEPATTERN = prev_num_of_matched = num_of_matched = files_matched = 0;
  240.     WORDBOUND = DELIMITER = 0;
  241.  
  242.     COMP_DIR[0] = '\0';
  243.     FREQ_FILE[0] = '\0';
  244.     HASH_FILE[0] = '\0';
  245.     STRING_FILE[0] = '\0';
  246.     BYTECOUNT = OFF;
  247.     PRINTOFFSET = OFF;
  248.     PRINTRECORD = ON;
  249.  
  250.     glimpse_clientdied = 0;    /* added 15th Feb 95 */
  251.  
  252.     /* Pattern, OldPattern, execfd, Numfiles are set in agrep_init: so no need to initialize */
  253.     reinit_value();
  254. }
  255.  
  256. void
  257. compute_next(M, Next, Next1)
  258. int M; 
  259. unsigned *Next, *Next1;
  260. {
  261.     int i, j=0, n,  k, temp;
  262.     int mid, pp;
  263.     int MM, base;
  264.     unsigned V[WORD];
  265.  
  266.     base = WORD - M;
  267.     temp = Bit[base]; 
  268.     Bit[base] = 0;
  269.     for (i=0; i<WORD; i++) V[i] = 0;
  270.     for (i=1; i<M; i++)
  271.     {  
  272.         j=0;
  273.         while (table[i][j] > 0 && j < 10) {
  274.             V[i] = V[i] | Bit[base + table[i][j++]];
  275.         }
  276.     }
  277.     Bit[base]=temp;
  278.     if(M <= SHORTREG)
  279.     {
  280.         k = exponen(M);
  281.         pp = 2*k;
  282.         for(i=k; i<pp ; i++)
  283.         {   
  284.             n = i;
  285.             Next[i]= (k>>1);
  286.             for(j=M; j>=1; j--)
  287.             {
  288.                 if(n & Bit[WORD]) Next[i] = Next[i] | V[j];
  289.                 n = (n>>1);
  290.             }
  291.         }      
  292.         return;
  293.     }
  294.     if(M > MAXREG) fprintf(stderr, "%s: regular expression too long\n", Progname);
  295.     MM = M;
  296.     if(M & 1) M=M+1;
  297.     k = exponen(M/2);
  298.     pp = 2*k;
  299.     mid = MM/2;
  300.     for(i=k; i<pp ; i++)
  301.     {     
  302.         n = i;
  303.         Next[i]= (Bit[base]>>1);
  304.         for(j=MM; j>mid ; j--)
  305.         {
  306.             if(n & Bit[WORD]) Next[i] = Next[i] | V[j-mid];
  307.             n = (n>>1);
  308.         }
  309.         n=i-k;
  310.         Next1[i-k] = 0;
  311.         for(j = 0; j<mid; j++)
  312.         {
  313.             if(n & Bit[WORD]) Next1[i-k] = Next1[i-k] | V[MM-j];
  314.             n = (n>>1);
  315.         }
  316.     }      
  317.     return;
  318. }
  319.  
  320. int
  321. exponen(m)
  322. int m;
  323. { 
  324.     int i, ex;
  325.     ex= 1;
  326.     for (i=0; i<m; i++) ex <<= 1;    /* was ex *= 2 */
  327.     return(ex);
  328. }
  329.  
  330. int
  331. re1(Text, M, D)
  332. int Text, M, D;
  333. {
  334.     register unsigned i, c, r0, r1, r2, r3, CMask, Newline, Init0, r_NO_ERR; 
  335.     register unsigned end;
  336.     register unsigned hh, LL=0, k;  /* Lower part */
  337.     int  FIRST_TIME=ON, num_read , j=0, base;
  338.     unsigned A[MaxRerror+1], B[MaxRerror+1];
  339.     unsigned Next[MaxNext], Next1[MaxNext];
  340.     CHAR *buffer;
  341.     int FIRST_LOOP = 1;
  342.  
  343.     r_NO_ERR = NO_ERR_MASK;
  344.     if(M > 30) {
  345.         fprintf(stderr, "%s: regular expression too long\n", Progname);
  346.         if (!EXITONERROR){
  347.             errno = AGREP_ERROR;
  348.             return -1;
  349.         }
  350.         else exit(2);
  351.     }
  352.     base = WORD - M;
  353.     hh = M/2;
  354.     for(i=WORD, j=0; j < hh ; i--, j++) LL = LL | Bit[i];
  355.     if(FIRST_IN_RE) compute_next(M, Next, Next1); 
  356.     /*SUN: try: change to memory allocation */
  357.     FIRST_IN_RE = 0;
  358.     Newline = '\n';
  359.     Init[0] = Bit[base];
  360.     if(HEAD) Init[0] = Init[0] | Bit[base+1];
  361.     for(i=1; i<= D; i++) Init[i] = Init[i-1] | Next[Init[i-1]>>hh] | Next1[Init[i-1]&LL];
  362.     Init1 = Init[0] | 1; 
  363.     Init0 = Init[0];
  364.     r2 = r3 = Init[0];
  365.     for(k=0; k<= D; k++) { 
  366.         A[k] = B[k] = Init[k]; 
  367.     }
  368.  
  369.     if ( D == 0 )
  370.     {
  371. #if    AGREP_POINTER
  372.         if (Text != -1)
  373.         {
  374. #endif    /*AGREP_POINTER*/
  375.         alloc_buf(Text, &buffer, BlockSize+Maxline+1);
  376.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  377.         {
  378.             i=Maxline; 
  379.             end = num_read + Maxline;
  380.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  381.             if(FIRST_LOOP) {         /* if first time in the loop add a newline */
  382.                 buffer[i-1] = '\n';  /* in front the  text.  */
  383.                 i--;
  384.                 CurrentByteOffset --;
  385.                 FIRST_LOOP = 0;
  386.             }
  387.  
  388.             /* RE1_PROCESS_WHEN_DZERO: the while-loop below */
  389.             while ( i < end )
  390.             {
  391.                 c = buffer[i++];
  392.                 CurrentByteOffset ++;
  393.                 CMask = Mask[c];
  394.                 if(c != Newline)
  395.                 {
  396.                     if(CMask != 0) {
  397.                         r1 = Init1 & r3;
  398.                         r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  399.                     }
  400.                     else  {
  401.                         r2 = r3 & Init1;
  402.                     }
  403.                 }
  404.                 else {
  405.                     j++;
  406.                     if (DELIMITER) CurrentByteOffset -= D_length;
  407.                     else CurrentByteOffset -= 1;
  408.                     r1 = Init1 & r3;            /* match against endofline */
  409.                     r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  410.                     if(TAIL) r2 = (Next[r2>>hh] | Next1[r2&LL]) | r2;                                        /* epsilon move */
  411.                     if(( r2 & 1 ) ^ INVERSE) {
  412.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  413.                             num_of_matched++;
  414.  
  415.                             if (agrep_finalfp != NULL) 
  416.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  417.                             else {
  418.                                 int outindex;
  419.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  420.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  421.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  422.                                 }
  423.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  424.                                     OUTPUT_OVERFLOW;
  425.                                     free_buf(Text, buffer);
  426.                                     return -1;
  427.                                 }
  428.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  429.                                 agrep_outpointer += outindex;
  430.                             }
  431.  
  432.                             free_buf(Text, buffer);
  433.                             NEW_FILE = OFF;
  434.                             return 0;
  435.                         }
  436.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  437.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  438.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  439.                             free_buf(Text, buffer);
  440.                             return 0;    /* done */
  441.                         }
  442.                     }
  443.                     r3 = Init0;
  444.                     r2 = (Next[r3>>hh] | Next1[r3&LL]) & CMask | Init0;
  445.                     /* match begin of line */
  446.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  447.                     else CurrentByteOffset += 1*1;
  448.                 }
  449.                 c = buffer[i++];
  450.                 CurrentByteOffset ++;
  451.                 CMask = Mask[c];
  452.                 if(c != Newline)
  453.                 {
  454.                     if(CMask != 0) {
  455.                         r1 = Init1 & r2;
  456.                         r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  457.                     }
  458.                     else   r3 = r2 & Init1;
  459.                 } /* if(NOT Newline) */
  460.                 else {
  461.                     j++;
  462.                     if (DELIMITER) CurrentByteOffset -= D_length;
  463.                     else CurrentByteOffset -= 1;
  464.                     r1 = Init1 & r2;            /* match against endofline */
  465.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  466.                     if(TAIL) r3 = ( Next[r3>>hh] | Next1[r3&LL] ) | r3;
  467.                     /* epsilon move */
  468.                     if(( r3 & 1 ) ^ INVERSE) {
  469.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  470.                             num_of_matched++;
  471.  
  472.                             if (agrep_finalfp != NULL)
  473.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  474.                             else {
  475.                                 int outindex;
  476.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  477.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  478.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  479.                                 }
  480.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  481.                                     OUTPUT_OVERFLOW;
  482.                                     free_buf(Text, buffer);
  483.                                     return -1;
  484.                                 }
  485.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  486.                                 agrep_outpointer += outindex;
  487.                             }
  488.  
  489.                             free_buf(Text, buffer);
  490.                             NEW_FILE = OFF;
  491.                             return 0;
  492.                         }
  493.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  494.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  495.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  496.                             free_buf(Text, buffer);
  497.                             return 0;    /* done */
  498.                         }
  499.                     }
  500.                     r2 = Init0;
  501.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | Init0;
  502.                     /* match begin of line */
  503.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  504.                     else CurrentByteOffset += 1*1;
  505.                 }
  506.             } /* while i < end ... */
  507.  
  508.             strncpy(buffer, buffer+num_read, Maxline);
  509.         } /* end while fill_buf()... */
  510.  
  511.         free_buf(Text, buffer);
  512.         return 0;
  513. #if    AGREP_POINTER
  514.         }
  515.         else {    /* within the memory buffer: assume it starts with a newline at position 0, the actual pattern follows that, and it ends with a '\n' */
  516.         num_read = agrep_inlen;
  517.         buffer = (CHAR *)agrep_inbuffer;
  518.         end = num_read;
  519.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  520.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  521.         i = 0;
  522.  
  523.             /* An exact copy of the above RE1_PROCESS_WHEN_DZERO: the while-loop below */
  524.             while ( i < end )
  525.             {
  526.                 c = buffer[i++];
  527.                 CurrentByteOffset ++;
  528.                 CMask = Mask[c];
  529.                 if(c != Newline)
  530.                 {
  531.                     if(CMask != 0) {
  532.                         r1 = Init1 & r3;
  533.                         r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  534.                     }
  535.                     else  {
  536.                         r2 = r3 & Init1;
  537.                     }
  538.                 }
  539.                 else {
  540.                     j++;
  541.                     if (DELIMITER) CurrentByteOffset -= D_length;
  542.                     else CurrentByteOffset -= 1;
  543.                     r1 = Init1 & r3;            /* match against endofline */
  544.                     r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  545.                     if(TAIL) r2 = (Next[r2>>hh] | Next1[r2&LL]) | r2;                                        /* epsilon move */
  546.                     if(( r2 & 1 ) ^ INVERSE) {
  547.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  548.                             num_of_matched++;
  549.  
  550.                             if (agrep_finalfp != NULL) 
  551.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  552.                             else {
  553.                                 int outindex;
  554.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  555.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  556.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  557.                                 }
  558.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  559.                                     OUTPUT_OVERFLOW;
  560.                                     free_buf(Text, buffer);
  561.                                     return -1;
  562.                                 }
  563.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  564.                                 agrep_outpointer += outindex;
  565.                             }
  566.  
  567.                             free_buf(Text, buffer);
  568.                             NEW_FILE = OFF;
  569.                             return 0;
  570.                         }
  571.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  572.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  573.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  574.                             free_buf(Text, buffer);
  575.                             return 0;    /* done */
  576.                         }
  577.                     }
  578.                     r3 = Init0;
  579.                     r2 = (Next[r3>>hh] | Next1[r3&LL]) & CMask | Init0;
  580.                     /* match begin of line */
  581.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  582.                     else CurrentByteOffset += 1*1;
  583.                 }
  584.                 c = buffer[i++];
  585.                 CurrentByteOffset ++;
  586.                 CMask = Mask[c];
  587.                 if(c != Newline)
  588.                 {
  589.                     if(CMask != 0) {
  590.                         r1 = Init1 & r2;
  591.                         r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  592.                     }
  593.                     else   r3 = r2 & Init1;
  594.                 } /* if(NOT Newline) */
  595.                 else {
  596.                     j++;
  597.                     if (DELIMITER) CurrentByteOffset -= D_length;
  598.                     else CurrentByteOffset -= 1;
  599.                     r1 = Init1 & r2;            /* match against endofline */
  600.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  601.                     if(TAIL) r3 = ( Next[r3>>hh] | Next1[r3&LL] ) | r3;
  602.                     /* epsilon move */
  603.                     if(( r3 & 1 ) ^ INVERSE) {
  604.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  605.                             num_of_matched++;
  606.  
  607.                             if (agrep_finalfp != NULL)
  608.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  609.                             else {
  610.                                 int outindex;
  611.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  612.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  613.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  614.                                 }
  615.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  616.                                     OUTPUT_OVERFLOW;
  617.                                     free_buf(Text, buffer);
  618.                                     return -1;
  619.                                 }
  620.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  621.                                 agrep_outpointer += outindex;
  622.                             }
  623.  
  624.                             free_buf(Text, buffer);
  625.                             NEW_FILE = OFF;
  626.                             return 0;
  627.                         }
  628.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  629.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  630.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  631.                             free_buf(Text, buffer);
  632.                             return 0;    /* done */
  633.                         }
  634.                     }
  635.                     r2 = Init0;
  636.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | Init0;
  637.                     /* match begin of line */
  638.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  639.                     else CurrentByteOffset += 1*1;
  640.                 }
  641.             } /* while i < end ... */
  642.  
  643.         return 0;
  644.         }
  645. #endif    /*AGREP_POINTER*/
  646.     } /*  end if (D == 0) */
  647.  
  648. #if    AGREP_POINTER
  649.     if (Text != -1)
  650.     {
  651. #endif    /*AGREP_POINTER*/
  652.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  653.         {
  654.             i=Maxline; 
  655.             end = Maxline + num_read;
  656.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  657.             if(FIRST_TIME) {         /* if first time in the loop add a newline */
  658.                 buffer[i-1] = '\n';  /* in front the  text.  */
  659.                 i--;
  660.                 CurrentByteOffset --;
  661.                 FIRST_TIME = 0;
  662.             }
  663.  
  664.             /* RE1_PROCESS_WHEN_DNOTZERO: the while loop below */
  665.             while (i < end )
  666.             {
  667.                 c = buffer[i];
  668.                 CMask = Mask[c];
  669.                 if(c !=  Newline)
  670.                 {
  671.                     if(CMask != 0) {  
  672.                         r2 = B[0];
  673.                         r1 = Init1 & r2;
  674.                         A[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  675.                         r3 = B[1];
  676.                         r1 = Init1 & r3;
  677.                         r0 = r2 | A[0];     /* A[0] | B[0] */
  678.                         A[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | (( r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  679.                         if(D == 1) goto Nextcharfile;
  680.                         r2 = B[2];
  681.                         r1 = Init1 & r2;
  682.                         r0 = r3 | A[1];
  683.                         A[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  684.                         if(D == 2) goto Nextcharfile;
  685.                         r3 = B[3];
  686.                         r1 = Init1 & r3;
  687.                         r0 = r2 | A[2];
  688.                         A[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  689.                         if(D == 3) goto Nextcharfile;
  690.                         r2 = B[4];
  691.                         r1 = Init1 & r2;
  692.                         r0 = r3 | A[3];
  693.                         A[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  694.                         if(D == 4)  goto Nextcharfile;
  695.                     }  /* if(CMask) */
  696.                     else  {
  697.                         r2 = B[0];
  698.                         A[0] = r2 & Init1; 
  699.                         r3 = B[1];
  700.                         r1 = Init1 & r3;
  701.                         r0 = r2 | A[0];
  702.                         A[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  703.                         if(D == 1) goto Nextcharfile;
  704.                         r2 = B[2];
  705.                         r1 = Init1 & r2;
  706.                         r0 = r3 | A[1];
  707.                         A[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  708.                         if(D == 2) goto Nextcharfile;
  709.                         r3 = B[3];
  710.                         r1 = Init1 & r3;
  711.                         r0 = r2 | A[2];
  712.                         A[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  713.                         if(D == 3) goto Nextcharfile;
  714.                         r2 = B[4];
  715.                         r1 = Init1 & r2;
  716.                         r0 = r3 | A[3];
  717.                         A[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  718.                         if(D == 4) goto Nextcharfile;
  719.                     }
  720.                 }
  721.                 else {  
  722.                     j++;
  723.                     if (DELIMITER) CurrentByteOffset -= D_length;
  724.                     else CurrentByteOffset -= 1;
  725.                     r1 = Init1 & B[D];            /* match against endofline */
  726.                     A[D] = ((Next[B[D]>>hh] | Next1[B[D]&LL]) & CMask) | r1;
  727.                     if(TAIL) A[D] = ( Next[A[D]>>hh] | Next1[A[D]&LL] ) | A[D]; 
  728.                     /* epsilon move */
  729.                     if(( A[D] & 1 ) ^ INVERSE) {
  730.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  731.                             num_of_matched++;
  732.  
  733.                             if (agrep_finalfp != NULL) 
  734.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  735.                             else {
  736.                                 int outindex;
  737.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  738.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  739.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  740.                                 }
  741.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  742.                                     OUTPUT_OVERFLOW;
  743.                                     free_buf(Text, buffer);
  744.                                     return -1;
  745.                                 }
  746.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  747.                                 agrep_outpointer += outindex;
  748.                             }
  749.  
  750.                             free_buf(Text, buffer);
  751.                             NEW_FILE = OFF;
  752.                             return 0;
  753.                         } 
  754.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  755.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  756.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  757.                             free_buf(Text, buffer);
  758.                             return 0;    /* done */
  759.                         }
  760.                     }
  761.                     for(k=0; k<=D; k++)  B[k] = Init[0];
  762.                     r1 = Init1 & B[0];
  763.                     A[0] = (( Next[B[0]>>hh] | Next1[B[0]&LL]) & CMask) | r1;
  764.                     for(k=1; k<=D; k++) {
  765.                         r3 = B[k];
  766.                         r1 = Init1 & r3;
  767.                         r2 = A[k-1] | B[k-1];
  768.                         A[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((B[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  769.                     }
  770.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  771.                     else CurrentByteOffset += 1*1;
  772.                 }
  773.     Nextcharfile: 
  774.                 i=i+1;
  775.                 CurrentByteOffset ++;
  776.                 c = buffer[i];
  777.                 CMask = Mask[c];
  778.                 if(c != Newline)
  779.                 {
  780.                     if(CMask != 0) {  
  781.                         r2 = A[0];
  782.                         r1 = Init1 & r2;
  783.                         B[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  784.                         r3 = A[1];
  785.                         r1 = Init1 & r3;
  786.                         r0 = B[0] | r2;
  787.                         B[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL]) & r_NO_ERR) | r1 ;  
  788.                         if(D == 1) goto Nextchar1file;
  789.                         r2 = A[2];
  790.                         r1 = Init1 & r2;
  791.                         r0 = B[1] | r3;
  792.                         B[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  793.                         if(D == 2) goto Nextchar1file;
  794.                         r3 = A[3];
  795.                         r1 = Init1 & r3;
  796.                         r0 = B[2] | r2;
  797.                         B[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  798.                         if(D == 3) goto Nextchar1file;
  799.                         r2 = A[4];
  800.                         r1 = Init1 & r2;
  801.                         r0 = B[3] | r3;
  802.                         B[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  803.                         if(D == 4)   goto Nextchar1file;
  804.                     }  /* if(CMask) */
  805.                     else  {
  806.                         r2 = A[0];
  807.                         B[0] = r2 & Init1; 
  808.                         r3 = A[1];
  809.                         r1 = Init1 & r3;
  810.                         r0 = B[0] | r2;
  811.                         B[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  812.                         if(D == 1) goto Nextchar1file;
  813.                         r2 = A[2];
  814.                         r1 = Init1 & r2;
  815.                         r0 = B[1] | r3;
  816.                         B[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  817.                         if(D == 2) goto Nextchar1file;
  818.                         r3 = A[3];
  819.                         r1 = Init1 & r3;
  820.                         r0 = B[2] | r2;
  821.                         B[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  822.                         if(D == 3) goto Nextchar1file;
  823.                         r2 = A[4];
  824.                         r1 = Init1 & r2;
  825.                         r0 = B[3] | r3;
  826.                         B[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  827.                         if(D == 4) goto Nextchar1file;
  828.                     }
  829.                 } /* if(NOT Newline) */
  830.                 else {  
  831.                     j++;
  832.                     if (DELIMITER) CurrentByteOffset -= D_length;
  833.                     else CurrentByteOffset -= 1;
  834.                     r1 = Init1 & A[D];            /* match against endofline */
  835.                     B[D] = ((Next[A[D]>>hh] | Next1[A[D]&LL]) & CMask) | r1;
  836.                     if(TAIL) B[D] = ( Next[B[D]>>hh] | Next1[B[D]&LL] ) | B[D]; 
  837.                     /* epsilon move */
  838.                     if(( B[D] & 1 ) ^ INVERSE) {
  839.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  840.                             num_of_matched++;
  841.  
  842.                             if (agrep_finalfp != NULL) 
  843.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  844.                             else {
  845.                                 int outindex;
  846.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  847.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  848.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  849.                                 }
  850.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  851.                                     OUTPUT_OVERFLOW;
  852.                                     free_buf(Text, buffer);
  853.                                     return -1;
  854.                                 }
  855.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  856.                                 agrep_outpointer += outindex;
  857.                             }
  858.  
  859.                             free_buf(Text, buffer);
  860.                             NEW_FILE = OFF;
  861.                             return 0;
  862.                         } 
  863.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  864.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  865.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  866.                             free_buf(Text, buffer);
  867.                             return 0;    /* done */
  868.                         }
  869.                     }
  870.                     for(k=0; k<=D; k++) A[k] = Init0; 
  871.                     r1 = Init1 & A[0];
  872.                     B[0] = ((Next[A[0]>>hh] | Next1[A[0]&LL]) & CMask) | r1;
  873.                     for(k=1; k<=D; k++) {
  874.                         r3 = A[k];
  875.                         r1 = Init1 & r3;
  876.                         r2 = A[k-1] | B[k-1];
  877.                         B[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((A[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  878.                     }
  879.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  880.                     else CurrentByteOffset += 1*1;
  881.                 }
  882.     Nextchar1file: 
  883.                 i=i+1;
  884.                 CurrentByteOffset ++;
  885.             } /* while i < end */
  886.  
  887.             strncpy(buffer, buffer+num_read, Maxline);
  888.         } /* while fill_buf... */
  889.         free_buf(Text, buffer);
  890.         return 0;
  891. #if    AGREP_POINTER
  892.     }
  893.     else {    /* within the memory buffer: assume it starts with a newline at position 0, the actual pattern follows that, and it ends with a '\n' */
  894.         num_read = agrep_inlen;
  895.         buffer = (CHAR *)agrep_inbuffer;
  896.         end = num_read;
  897.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  898.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  899.         i = 0;
  900.  
  901.             /* An exact copy of the above RE1_PROCESS_WHEN_DNOTZERO: the while loop below */
  902.             while (i < end )
  903.             {
  904.                 c = buffer[i];
  905.                 CMask = Mask[c];
  906.                 if(c !=  Newline)
  907.                 {
  908.                     if(CMask != 0) {  
  909.                         r2 = B[0];
  910.                         r1 = Init1 & r2;
  911.                         A[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  912.                         r3 = B[1];
  913.                         r1 = Init1 & r3;
  914.                         r0 = r2 | A[0];     /* A[0] | B[0] */
  915.                         A[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | (( r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  916.                         if(D == 1) goto Nextcharmem;
  917.                         r2 = B[2];
  918.                         r1 = Init1 & r2;
  919.                         r0 = r3 | A[1];
  920.                         A[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  921.                         if(D == 2) goto Nextcharmem;
  922.                         r3 = B[3];
  923.                         r1 = Init1 & r3;
  924.                         r0 = r2 | A[2];
  925.                         A[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  926.                         if(D == 3) goto Nextcharmem;
  927.                         r2 = B[4];
  928.                         r1 = Init1 & r2;
  929.                         r0 = r3 | A[3];
  930.                         A[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  931.                         if(D == 4)  goto Nextcharmem;
  932.                     }  /* if(CMask) */
  933.                     else  {
  934.                         r2 = B[0];
  935.                         A[0] = r2 & Init1; 
  936.                         r3 = B[1];
  937.                         r1 = Init1 & r3;
  938.                         r0 = r2 | A[0];
  939.                         A[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  940.                         if(D == 1) goto Nextcharmem;
  941.                         r2 = B[2];
  942.                         r1 = Init1 & r2;
  943.                         r0 = r3 | A[1];
  944.                         A[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  945.                         if(D == 2) goto Nextcharmem;
  946.                         r3 = B[3];
  947.                         r1 = Init1 & r3;
  948.                         r0 = r2 | A[2];
  949.                         A[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  950.                         if(D == 3) goto Nextcharmem;
  951.                         r2 = B[4];
  952.                         r1 = Init1 & r2;
  953.                         r0 = r3 | A[3];
  954.                         A[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  955.                         if(D == 4) goto Nextcharmem;
  956.                     }
  957.                 }
  958.                 else {  
  959.                     j++;
  960.                     if (DELIMITER) CurrentByteOffset -= D_length;
  961.                     else CurrentByteOffset -= 1;
  962.                     r1 = Init1 & B[D];            /* match against endofline */
  963.                     A[D] = ((Next[B[D]>>hh] | Next1[B[D]&LL]) & CMask) | r1;
  964.                     if(TAIL) A[D] = ( Next[A[D]>>hh] | Next1[A[D]&LL] ) | A[D]; 
  965.                     /* epsilon move */
  966.                     if(( A[D] & 1 ) ^ INVERSE) {
  967.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  968.                             num_of_matched++;
  969.  
  970.                             if (agrep_finalfp != NULL) 
  971.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  972.                             else {
  973.                                 int outindex;
  974.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  975.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  976.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  977.                                 }
  978.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  979.                                     OUTPUT_OVERFLOW;
  980.                                     free_buf(Text, buffer);
  981.                                     return -1;
  982.                                 }
  983.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  984.                                 agrep_outpointer += outindex;
  985.                             }
  986.  
  987.                             free_buf(Text, buffer);
  988.                             NEW_FILE = OFF;
  989.                             return 0;
  990.                         } 
  991.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  992.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  993.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  994.                             free_buf(Text, buffer);
  995.                             return 0;    /* done */
  996.                         }
  997.                     }
  998.                     for(k=0; k<=D; k++)  B[k] = Init[0];
  999.                     r1 = Init1 & B[0];
  1000.                     A[0] = (( Next[B[0]>>hh] | Next1[B[0]&LL]) & CMask) | r1;
  1001.                     for(k=1; k<=D; k++) {
  1002.                         r3 = B[k];
  1003.                         r1 = Init1 & r3;
  1004.                         r2 = A[k-1] | B[k-1];
  1005.                         A[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((B[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  1006.                     }
  1007.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1008.                     else CurrentByteOffset += 1*1;
  1009.                 }
  1010.     Nextcharmem: 
  1011.                 i=i+1;
  1012.                 CurrentByteOffset ++;
  1013.                 c = buffer[i];
  1014.                 CMask = Mask[c];
  1015.                 if(c != Newline)
  1016.                 {
  1017.                     if(CMask != 0) {  
  1018.                         r2 = A[0];
  1019.                         r1 = Init1 & r2;
  1020.                         B[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  1021.                         r3 = A[1];
  1022.                         r1 = Init1 & r3;
  1023.                         r0 = B[0] | r2;
  1024.                         B[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL]) & r_NO_ERR) | r1 ;  
  1025.                         if(D == 1) goto Nextchar1mem;
  1026.                         r2 = A[2];
  1027.                         r1 = Init1 & r2;
  1028.                         r0 = B[1] | r3;
  1029.                         B[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1030.                         if(D == 2) goto Nextchar1mem;
  1031.                         r3 = A[3];
  1032.                         r1 = Init1 & r3;
  1033.                         r0 = B[2] | r2;
  1034.                         B[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1035.                         if(D == 3) goto Nextchar1mem;
  1036.                         r2 = A[4];
  1037.                         r1 = Init1 & r2;
  1038.                         r0 = B[3] | r3;
  1039.                         B[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1040.                         if(D == 4)   goto Nextchar1mem;
  1041.                     }  /* if(CMask) */
  1042.                     else  {
  1043.                         r2 = A[0];
  1044.                         B[0] = r2 & Init1; 
  1045.                         r3 = A[1];
  1046.                         r1 = Init1 & r3;
  1047.                         r0 = B[0] | r2;
  1048.                         B[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1049.                         if(D == 1) goto Nextchar1mem;
  1050.                         r2 = A[2];
  1051.                         r1 = Init1 & r2;
  1052.                         r0 = B[1] | r3;
  1053.                         B[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1054.                         if(D == 2) goto Nextchar1mem;
  1055.                         r3 = A[3];
  1056.                         r1 = Init1 & r3;
  1057.                         r0 = B[2] | r2;
  1058.                         B[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1059.                         if(D == 3) goto Nextchar1mem;
  1060.                         r2 = A[4];
  1061.                         r1 = Init1 & r2;
  1062.                         r0 = B[3] | r3;
  1063.                         B[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1064.                         if(D == 4) goto Nextchar1mem;
  1065.                     }
  1066.                 } /* if(NOT Newline) */
  1067.                 else {  
  1068.                     j++;
  1069.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1070.                     else CurrentByteOffset -= 1;
  1071.                     r1 = Init1 & A[D];            /* match against endofline */
  1072.                     B[D] = ((Next[A[D]>>hh] | Next1[A[D]&LL]) & CMask) | r1;
  1073.                     if(TAIL) B[D] = ( Next[B[D]>>hh] | Next1[B[D]&LL] ) | B[D]; 
  1074.                     /* epsilon move */
  1075.                     if(( B[D] & 1 ) ^ INVERSE) {
  1076.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1077.                             num_of_matched++;
  1078.  
  1079.                             if (agrep_finalfp != NULL) 
  1080.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1081.                             else {
  1082.                                 int outindex;
  1083.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1084.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1085.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1086.                                 }
  1087.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1088.                                     OUTPUT_OVERFLOW;
  1089.                                     free_buf(Text, buffer);
  1090.                                     return -1;
  1091.                                 }
  1092.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1093.                                 agrep_outpointer += outindex;
  1094.                             }
  1095.  
  1096.                             free_buf(Text, buffer);
  1097.                             NEW_FILE = OFF;
  1098.                             return 0;
  1099.                         } 
  1100.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1101.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1102.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1103.                             free_buf(Text, buffer);
  1104.                             return 0;    /* done */
  1105.                         }
  1106.                     }
  1107.                     for(k=0; k<=D; k++) A[k] = Init0; 
  1108.                     r1 = Init1 & A[0];
  1109.                     B[0] = ((Next[A[0]>>hh] | Next1[A[0]&LL]) & CMask) | r1;
  1110.                     for(k=1; k<=D; k++) {
  1111.                         r3 = A[k];
  1112.                         r1 = Init1 & r3;
  1113.                         r2 = A[k-1] | B[k-1];
  1114.                         B[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((A[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  1115.                     }
  1116.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1117.                     else CurrentByteOffset += 1*1;
  1118.                 }
  1119.     Nextchar1mem: 
  1120.                 i=i+1;
  1121.                 CurrentByteOffset ++;
  1122.             } /* while i < end */
  1123.  
  1124.         return 0;
  1125.     }
  1126. #endif    /*AGREP_POINTER*/
  1127. } /* re1 */
  1128.  
  1129. int
  1130. re(Text, M, D)
  1131. int Text, M, D;
  1132. {
  1133.     register unsigned i, c, r1, r2, r3, CMask, k, Newline, Init0, Init1, end; 
  1134.     register unsigned r_even, r_odd, r_NO_ERR ;
  1135.     unsigned RMask[MAXSYM];
  1136.     unsigned A[MaxRerror+1], B[MaxRerror+1];
  1137.     int num_read, j=0, lasti, base, ResidueSize; 
  1138.     int FIRST_TIME; /* Flag */
  1139.     CHAR *buffer;
  1140.  
  1141.     base = WORD - M;
  1142.     k = 2*exponen(M);
  1143.     if(FIRST_IN_RE) {
  1144.         compute_next(M, Next, Next1); 
  1145.         FIRST_IN_RE = 0;    
  1146.     }
  1147.     for(i=0; i< MAXSYM; i++) RMask[i] = Mask[i];
  1148.     r_NO_ERR = NO_ERR_MASK;
  1149.     Newline = '\n';
  1150.     Init0 = Init[0] = Bit[base];
  1151.     if(HEAD) Init0  = Init[0] = Init0 | Bit[base+1] ;
  1152.     for(i=1; i<= D; i++) Init[i] = Init[i-1] | Next[Init[i-1]]; /* can be out? */
  1153.     Init1 = Init0 | 1; 
  1154.     r2 = r3 = Init0;
  1155.     for(k=0; k<= D; k++) { 
  1156.         A[k] = B[k] = Init[0]; 
  1157.     }  /* can be out? */
  1158.     FIRST_TIME = ON;
  1159.     alloc_buf(Text, &buffer, BlockSize+Maxline+1);
  1160.     if ( D == 0 )
  1161.     {
  1162. #if    AGREP_POINTER
  1163.         if(Text != -1) {
  1164. #endif    /*AGREP_POINTER*/
  1165.         lasti = Maxline;
  1166.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  1167.         {
  1168.             i=Maxline; 
  1169.             end = Maxline + num_read ;
  1170.             if((num_read < BlockSize)&&buffer[end-1] != '\n') buffer[end] = '\n';
  1171.             if(FIRST_TIME) {
  1172.                 buffer[i-1] = '\n';
  1173.                 i--;
  1174.                 CurrentByteOffset --;
  1175.                 FIRST_TIME = 0;
  1176.             }
  1177.  
  1178.             /* RE_PROCESS_WHEN_DZERO: the while-loop below */
  1179.             while (i < end) 
  1180.             {
  1181.                 c = buffer[i++];
  1182.                 CurrentByteOffset ++;
  1183.                 CMask = RMask[c];
  1184.                 if(c != Newline)
  1185.                 {  
  1186.                     r1 = Init1 & r3;
  1187.                     r2 = (Next[r3] & CMask) | r1;
  1188.                 }
  1189.                 else {  
  1190.                     r1 = Init1 & r3;            /* match against '\n' */
  1191.                     r2 = Next[r3] & CMask | r1;
  1192.                     j++;
  1193.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1194.                     else CurrentByteOffset -= 1;
  1195.                     if(TAIL) r2 = Next[r2] | r2 ;   /* epsilon move */
  1196.                     if(( r2 & 1) ^ INVERSE) {
  1197.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1198.                             num_of_matched++;
  1199.  
  1200.                             if (agrep_finalfp != NULL) 
  1201.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1202.                             else {
  1203.                                 int outindex;
  1204.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1205.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1206.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1207.                                 }
  1208.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1209.                                     OUTPUT_OVERFLOW;
  1210.                                     free_buf(Text, buffer);
  1211.                                     return -1;
  1212.                                 }
  1213.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1214.                                 agrep_outpointer += outindex;
  1215.                             }
  1216.  
  1217.                             free_buf(Text, buffer);
  1218.                             NEW_FILE = OFF;
  1219.                             return 0;
  1220.                         } 
  1221.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1222.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1223.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1224.                             free_buf(Text, buffer);
  1225.                             return 0;    /* done */
  1226.                         }
  1227.                     }
  1228.                     lasti = i - 1;
  1229.                     r3 = Init0;
  1230.                     r2 = (Next[r3] & CMask) | Init0;
  1231.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1232.                     else CurrentByteOffset += 1*1;
  1233.                 }
  1234.                 c = buffer[i++];   
  1235.                 CurrentByteOffset ++;
  1236.                 CMask = RMask[c];
  1237.                 if(c != Newline)
  1238.                 {
  1239.                     r1 = Init1 & r2;
  1240.                     r3 = (Next[r2] & CMask) | r1;
  1241.                 }
  1242.                 else {  
  1243.                     j++;
  1244.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1245.                     else CurrentByteOffset -= 1;
  1246.                     r1 = Init1 & r2;            /* match against endofline */
  1247.                     r3 = Next[r2] & CMask | r1;
  1248.                     if(TAIL) r3 = Next[r3] | r3;
  1249.                     if(( r3 & 1) ^ INVERSE) {
  1250.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1251.                             num_of_matched++;
  1252.  
  1253.                             if (agrep_finalfp != NULL) 
  1254.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1255.                             else {
  1256.                                 int outindex;
  1257.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1258.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1259.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1260.                                 }
  1261.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1262.                                     OUTPUT_OVERFLOW;
  1263.                                     free_buf(Text, buffer);
  1264.                                     return -1;
  1265.                                 }
  1266.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1267.                                 agrep_outpointer += outindex;
  1268.                             }
  1269.  
  1270.                             free_buf(Text, buffer);
  1271.                             NEW_FILE = OFF;
  1272.                             return 0;
  1273.                         } 
  1274.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1275.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1276.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1277.                             free_buf(Text, buffer);
  1278.                             return 0;    /* done */
  1279.                         }
  1280.                     }
  1281.                     lasti = i - 1;
  1282.                     r2 = Init0; 
  1283.                     r3 = (Next[r2] & CMask) | Init0;  /* match the newline */
  1284.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1285.                     else CurrentByteOffset += 1*1;
  1286.                 }
  1287.             } /* while */
  1288.  
  1289.             ResidueSize = Maxline + num_read - lasti;
  1290.             if(ResidueSize > Maxline) {
  1291.                 ResidueSize = Maxline;  
  1292.             }
  1293.             strncpy(buffer+Maxline-ResidueSize, buffer+lasti, ResidueSize);
  1294.             lasti = Maxline - ResidueSize;
  1295.         } /* while fill_buf() */
  1296.         free_buf(Text, buffer);
  1297.         return 0;
  1298. #if    AGREP_POINTER
  1299.         }
  1300.         else {
  1301.         num_read = agrep_inlen;
  1302.         buffer = (CHAR *)agrep_inbuffer;
  1303.         end = num_read;
  1304.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  1305.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  1306.         i = 0;
  1307.         lasti = 1;
  1308.  
  1309.             /* An exact copy of the above RE_PROCESS_WHEN_DZERO: the while-loop below */
  1310.             while (i < end) 
  1311.             {
  1312.                 c = buffer[i++];
  1313.                 CurrentByteOffset ++;
  1314.                 CMask = RMask[c];
  1315.                 if(c != Newline)
  1316.                 {  
  1317.                     r1 = Init1 & r3;
  1318.                     r2 = (Next[r3] & CMask) | r1;
  1319.                 }
  1320.                 else {  
  1321.                     r1 = Init1 & r3;            /* match against '\n' */
  1322.                     r2 = Next[r3] & CMask | r1;
  1323.                     j++;
  1324.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1325.                     else CurrentByteOffset -= 1;
  1326.                     if(TAIL) r2 = Next[r2] | r2 ;   /* epsilon move */
  1327.                     if(( r2 & 1) ^ INVERSE) {
  1328.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1329.                             num_of_matched++;
  1330.  
  1331.                             if (agrep_finalfp != NULL) 
  1332.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1333.                             else {
  1334.                                 int outindex;
  1335.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1336.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1337.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1338.                                 }
  1339.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1340.                                     OUTPUT_OVERFLOW;
  1341.                                     free_buf(Text, buffer);
  1342.                                     return -1;
  1343.                                 }
  1344.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1345.                                 agrep_outpointer += outindex;
  1346.                             }
  1347.  
  1348.                             free_buf(Text, buffer);
  1349.                             NEW_FILE = OFF;
  1350.                             return 0;
  1351.                         } 
  1352.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1353.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1354.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1355.                             free_buf(Text, buffer);
  1356.                             return 0;    /* done */
  1357.                         }
  1358.                     }
  1359.                     lasti = i - 1;
  1360.                     r3 = Init0;
  1361.                     r2 = (Next[r3] & CMask) | Init0;
  1362.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1363.                     else CurrentByteOffset += 1*1;
  1364.                 }
  1365.                 c = buffer[i++];   
  1366.                 CurrentByteOffset ++;
  1367.                 CMask = RMask[c];
  1368.                 if(c != Newline)
  1369.                 {
  1370.                     r1 = Init1 & r2;
  1371.                     r3 = (Next[r2] & CMask) | r1;
  1372.                 }
  1373.                 else {  
  1374.                     j++;
  1375.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1376.                     else CurrentByteOffset -= 1;
  1377.                     r1 = Init1 & r2;            /* match against endofline */
  1378.                     r3 = Next[r2] & CMask | r1;
  1379.                     if(TAIL) r3 = Next[r3] | r3;
  1380.                     if(( r3 & 1) ^ INVERSE) {
  1381.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1382.                             num_of_matched++;
  1383.  
  1384.                             if (agrep_finalfp != NULL) 
  1385.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1386.                             else {
  1387.                                 int outindex;
  1388.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1389.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1390.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1391.                                 }
  1392.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1393.                                     OUTPUT_OVERFLOW;
  1394.                                     free_buf(Text, buffer);
  1395.                                     return -1;
  1396.                                 }
  1397.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1398.                                 agrep_outpointer += outindex;
  1399.                             }
  1400.  
  1401.                             free_buf(Text, buffer);
  1402.                             NEW_FILE = OFF;
  1403.                             return 0;
  1404.                         } 
  1405.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1406.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1407.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1408.                             free_buf(Text, buffer);
  1409.                             return 0;    /* done */
  1410.                         }
  1411.                     }
  1412.                     lasti = i - 1;
  1413.                     r2 = Init0; 
  1414.                     r3 = (Next[r2] & CMask) | Init0;  /* match the newline */
  1415.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1416.                     else CurrentByteOffset += 1*1;
  1417.                 }
  1418.             } /* while */
  1419.  
  1420.         /* If a residue is left for within-memory-buffer, since nothing can be "read" after that, we can ignore it: as if only 1 iteration of while */
  1421.         return 0;
  1422.         }
  1423. #endif    /*AGREP_POINTER*/
  1424.     } /* end if(D==0) */
  1425.  
  1426. #if    AGREP_POINTER
  1427.     if (Text != -1) {
  1428. #endif    /*AGREP_POINTER*/
  1429.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  1430.         {
  1431.             i=Maxline; 
  1432.             end = Maxline+num_read;
  1433.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  1434.             if(FIRST_TIME) {
  1435.                 buffer[i-1] = '\n';
  1436.                 i--;
  1437.                 CurrentByteOffset --;
  1438.                 FIRST_TIME = 0;
  1439.             }
  1440.  
  1441.             /* RE_PROCESS_WHEN_DNOTZERO: the while-loop below */
  1442.             while (i < end)
  1443.             {   
  1444.                 c = buffer[i++];
  1445.                 CurrentByteOffset ++;
  1446.                 CMask = RMask[c];
  1447.                 if (c != Newline)
  1448.                 {  
  1449.                     r_even = B[0];
  1450.                     r1 = Init1 & r_even;
  1451.                     A[0] = (Next[r_even] & CMask) | r1;
  1452.                     r_odd = B[1];
  1453.                     r1 = Init1 & r_odd;
  1454.                     r2 = (r_even | Next[r_even|A[0]]) &r_NO_ERR;
  1455.                     A[1] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1456.                     if(D == 1) goto Nextcharfile;
  1457.                     r_even = B[2];
  1458.                     r1 = Init1 & r_even;
  1459.                     r2 = (r_odd | Next[r_odd|A[1]]) &r_NO_ERR;
  1460.                     A[2] = (Next[r_even] & CMask) | r2 | r1 ;  
  1461.                     if(D == 2) goto Nextcharfile;
  1462.                     r_odd = B[3];
  1463.                     r1 = Init1 & r_odd;
  1464.                     r2 = (r_even | Next[r_even|A[2]]) &r_NO_ERR;
  1465.                     A[3] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1466.                     if(D == 3) goto Nextcharfile;
  1467.                     r_even = B[4];
  1468.                     r1 = Init1 & r_even;
  1469.                     r2 = (r_odd | Next[r_odd|A[3]]) &r_NO_ERR;
  1470.                     A[4] = (Next[r_even] & CMask) | r2 | r1 ;  
  1471.                     goto Nextcharfile;
  1472.                 } /* if NOT Newline */
  1473.                 else {  
  1474.                     j++;
  1475.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1476.                     else CurrentByteOffset -= 1;
  1477.                     r1 = Init1 & B[D];               /* match endofline */
  1478.                     A[D] = (Next[B[D]] & CMask) | r1;
  1479.                     if(TAIL) A[D] = Next[A[D]] | A[D];
  1480.                     if((A[D] & 1) ^ INVERSE )  {
  1481.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1482.                             num_of_matched++;    
  1483.  
  1484.                             if (agrep_finalfp != NULL) 
  1485.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1486.                             else {
  1487.                                 int outindex;
  1488.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1489.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1490.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1491.                                 }
  1492.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1493.                                     OUTPUT_OVERFLOW;
  1494.                                     free_buf(Text, buffer);
  1495.                                     return -1;
  1496.                                 }
  1497.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1498.                                 agrep_outpointer += outindex;
  1499.                             }
  1500.  
  1501.                             free_buf(Text, buffer);
  1502.                             NEW_FILE = OFF;
  1503.                             return 0;
  1504.                         }  
  1505.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1506.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1507.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1508.                             free_buf(Text, buffer);
  1509.                             return 0;    /* done */
  1510.                         }
  1511.                     }
  1512.                     for(k=0; k<= D; k++) { 
  1513.                         A[k] = B[k] = Init[k]; 
  1514.                     }
  1515.                     r1 = Init1 & B[0]; 
  1516.                     A[0] = (Next[B[0]] & CMask) | r1;
  1517.                     for(k=1; k<= D; k++) {
  1518.                         r1 = Init1 & B[k];
  1519.                         r2 = (B[k-1] | Next[A[k-1]|B[k-1]]) &r_NO_ERR;
  1520.                         A[k] = (Next[B[k]] & CMask) | r1 | r2;
  1521.                     }
  1522.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1523.                     else CurrentByteOffset += 1*1;
  1524.                 }
  1525.     Nextcharfile: 
  1526.                 c = buffer[i];
  1527.                 CMask = RMask[c];
  1528.                 if(c != Newline)
  1529.                 { 
  1530.                     r1 = Init1 & A[0];
  1531.                     B[0] = (Next[A[0]] & CMask) | r1;
  1532.                     r1 = Init1 & A[1];
  1533.                     B[1] = (Next[A[1]] & CMask) | ((A[0] | Next[A[0] | B[0]]) & r_NO_ERR) | r1 ;  
  1534.                     if(D == 1) goto Nextchar1file;
  1535.                     r1 = Init1 & A[2];
  1536.                     B[2] = (Next[A[2]] & CMask) | ((A[1] | Next[A[1] | B[1]]) &r_NO_ERR) | r1 ;  
  1537.                     if(D == 2) goto Nextchar1file;
  1538.                     r1 = Init1 & A[3];
  1539.                     B[3] = (Next[A[3]] & CMask) | ((A[2] | Next[A[2] | B[2]])&r_NO_ERR) | r1 ;  
  1540.                     if(D == 3) goto Nextchar1file;
  1541.                     r1 = Init1 & A[4];
  1542.                     B[4] = (Next[A[4]] & CMask) | ((A[3] | Next[A[3] | B[3]])&r_NO_ERR) | r1 ;  
  1543.                     goto Nextchar1file;
  1544.                 } /* if(NOT Newline) */
  1545.                 else {  
  1546.                     j++;
  1547.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1548.                     else CurrentByteOffset -= 1;
  1549.                     r1 = Init1 & A[D];               /* match endofline */
  1550.                     B[D] = (Next[A[D]] & CMask) | r1;
  1551.                     if(TAIL) B[D] = Next[B[D]] | B[D];
  1552.                     if((B[D] & 1) ^ INVERSE )  {
  1553.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1554.                             num_of_matched++;
  1555.  
  1556.                             if (agrep_finalfp != NULL) 
  1557.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1558.                             else {
  1559.                                 int outindex;
  1560.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1561.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1562.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1563.                                 }
  1564.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1565.                                     OUTPUT_OVERFLOW;
  1566.                                     free_buf(Text, buffer);
  1567.                                     return -1;
  1568.                                 }
  1569.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1570.                                 agrep_outpointer += outindex;
  1571.                             }
  1572.  
  1573.                             free_buf(Text, buffer);
  1574.                             NEW_FILE = OFF;
  1575.                             return 0;
  1576.                         } 
  1577.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1578.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1579.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1580.                             free_buf(Text, buffer);
  1581.                             return 0;    /* done */
  1582.                         }
  1583.                     }
  1584.                     for(k=0; k<= D; k++) { 
  1585.                         A[k] = B[k] = Init[k]; 
  1586.                     }
  1587.                     r1 = Init1 & A[0]; 
  1588.                     B[0] = (Next[A[0]] & CMask) | r1;
  1589.                     for(k=1; k<= D; k++) {
  1590.                         r1 = Init1 & A[k];
  1591.                         r2 = (A[k-1] | Next[A[k-1]|B[k-1]])&r_NO_ERR;
  1592.                         B[k] = (Next[A[k]] & CMask) | r1 | r2;
  1593.                     }
  1594.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1595.                     else CurrentByteOffset += 1*1;
  1596.                 }
  1597.     Nextchar1file: 
  1598.                 i++;
  1599.                 CurrentByteOffset ++;
  1600.             } /* while i < end */
  1601.  
  1602.             strncpy(buffer, buffer+num_read, Maxline);
  1603.         } /* while  fill_buf() */
  1604.         free_buf(Text, buffer);
  1605.         return 0;
  1606. #if    AGREP_POINTER
  1607.     }
  1608.     else {
  1609.         num_read = agrep_inlen;
  1610.         buffer = (CHAR *)agrep_inbuffer;
  1611.         end = num_read;
  1612.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  1613.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  1614.         i = 0;
  1615.  
  1616.             /* An exact copy of the above RE_PROCESS_WHEN_DNOTZERO: the while-loop below */
  1617.             while (i < end)
  1618.             {   
  1619.                 c = buffer[i++];
  1620.                 CurrentByteOffset ++;
  1621.                 CMask = RMask[c];
  1622.                 if (c != Newline)
  1623.                 {  
  1624.                     r_even = B[0];
  1625.                     r1 = Init1 & r_even;
  1626.                     A[0] = (Next[r_even] & CMask) | r1;
  1627.                     r_odd = B[1];
  1628.                     r1 = Init1 & r_odd;
  1629.                     r2 = (r_even | Next[r_even|A[0]]) &r_NO_ERR;
  1630.                     A[1] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1631.                     if(D == 1) goto Nextcharmem;
  1632.                     r_even = B[2];
  1633.                     r1 = Init1 & r_even;
  1634.                     r2 = (r_odd | Next[r_odd|A[1]]) &r_NO_ERR;
  1635.                     A[2] = (Next[r_even] & CMask) | r2 | r1 ;  
  1636.                     if(D == 2) goto Nextcharmem;
  1637.                     r_odd = B[3];
  1638.                     r1 = Init1 & r_odd;
  1639.                     r2 = (r_even | Next[r_even|A[2]]) &r_NO_ERR;
  1640.                     A[3] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1641.                     if(D == 3) goto Nextcharmem;
  1642.                     r_even = B[4];
  1643.                     r1 = Init1 & r_even;
  1644.                     r2 = (r_odd | Next[r_odd|A[3]]) &r_NO_ERR;
  1645.                     A[4] = (Next[r_even] & CMask) | r2 | r1 ;  
  1646.                     goto Nextcharmem;
  1647.                 } /* if NOT Newline */
  1648.                 else {  
  1649.                     j++;
  1650.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1651.                     else CurrentByteOffset -= 1;
  1652.                     r1 = Init1 & B[D];               /* match endofline */
  1653.                     A[D] = (Next[B[D]] & CMask) | r1;
  1654.                     if(TAIL) A[D] = Next[A[D]] | A[D];
  1655.                     if((A[D] & 1) ^ INVERSE )  {
  1656.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1657.                             num_of_matched++;    
  1658.  
  1659.                             if (agrep_finalfp != NULL) 
  1660.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1661.                             else {
  1662.                                 int outindex;
  1663.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1664.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1665.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1666.                                 }
  1667.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1668.                                     OUTPUT_OVERFLOW;
  1669.                                     free_buf(Text, buffer);
  1670.                                     return -1;
  1671.                                 }
  1672.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1673.                                 agrep_outpointer += outindex;
  1674.                             }
  1675.  
  1676.                             free_buf(Text, buffer);
  1677.                             NEW_FILE = OFF;
  1678.                             return 0;
  1679.                         }  
  1680.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1681.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1682.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1683.                             free_buf(Text, buffer);
  1684.                             return 0;    /* done */
  1685.                         }
  1686.                     }
  1687.                     for(k=0; k<= D; k++) { 
  1688.                         A[k] = B[k] = Init[k]; 
  1689.                     }
  1690.                     r1 = Init1 & B[0]; 
  1691.                     A[0] = (Next[B[0]] & CMask) | r1;
  1692.                     for(k=1; k<= D; k++) {
  1693.                         r1 = Init1 & B[k];
  1694.                         r2 = (B[k-1] | Next[A[k-1]|B[k-1]]) &r_NO_ERR;
  1695.                         A[k] = (Next[B[k]] & CMask) | r1 | r2;
  1696.                     }
  1697.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1698.                     else CurrentByteOffset += 1*1;
  1699.                 }
  1700.     Nextcharmem: 
  1701.                 c = buffer[i];
  1702.                 CMask = RMask[c];
  1703.                 if(c != Newline)
  1704.                 { 
  1705.                     r1 = Init1 & A[0];
  1706.                     B[0] = (Next[A[0]] & CMask) | r1;
  1707.                     r1 = Init1 & A[1];
  1708.                     B[1] = (Next[A[1]] & CMask) | ((A[0] | Next[A[0] | B[0]]) & r_NO_ERR) | r1 ;  
  1709.                     if(D == 1) goto Nextchar1mem;
  1710.                     r1 = Init1 & A[2];
  1711.                     B[2] = (Next[A[2]] & CMask) | ((A[1] | Next[A[1] | B[1]]) &r_NO_ERR) | r1 ;  
  1712.                     if(D == 2) goto Nextchar1mem;
  1713.                     r1 = Init1 & A[3];
  1714.                     B[3] = (Next[A[3]] & CMask) | ((A[2] | Next[A[2] | B[2]])&r_NO_ERR) | r1 ;  
  1715.                     if(D == 3) goto Nextchar1mem;
  1716.                     r1 = Init1 & A[4];
  1717.                     B[4] = (Next[A[4]] & CMask) | ((A[3] | Next[A[3] | B[3]])&r_NO_ERR) | r1 ;  
  1718.                     goto Nextchar1mem;
  1719.                 } /* if(NOT Newline) */
  1720.                 else {  
  1721.                     j++;
  1722.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1723.                     else CurrentByteOffset -= 1;
  1724.                     r1 = Init1 & A[D];               /* match endofline */
  1725.                     B[D] = (Next[A[D]] & CMask) | r1;
  1726.                     if(TAIL) B[D] = Next[B[D]] | B[D];
  1727.                     if((B[D] & 1) ^ INVERSE )  {
  1728.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1729.                             num_of_matched++;
  1730.  
  1731.                             if (agrep_finalfp != NULL) 
  1732.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1733.                             else {
  1734.                                 int outindex;
  1735.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1736.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1737.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1738.                                 }
  1739.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1740.                                     OUTPUT_OVERFLOW;
  1741.                                     free_buf(Text, buffer);
  1742.                                     return -1;
  1743.                                 }
  1744.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1745.                                 agrep_outpointer += outindex;
  1746.                             }
  1747.  
  1748.                             free_buf(Text, buffer);
  1749.                             NEW_FILE = OFF;
  1750.                             return 0;
  1751.                         } 
  1752.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1753.                         if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  1754.                             ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  1755.                             free_buf(Text, buffer);
  1756.                             return 0;    /* done */
  1757.                         }
  1758.                     }
  1759.                     for(k=0; k<= D; k++) { 
  1760.                         A[k] = B[k] = Init[k]; 
  1761.                     }
  1762.                     r1 = Init1 & A[0]; 
  1763.                     B[0] = (Next[A[0]] & CMask) | r1;
  1764.                     for(k=1; k<= D; k++) {
  1765.                         r1 = Init1 & A[k];
  1766.                         r2 = (A[k-1] | Next[A[k-1]|B[k-1]])&r_NO_ERR;
  1767.                         B[k] = (Next[A[k]] & CMask) | r1 | r2;
  1768.                     }
  1769.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1770.                     else CurrentByteOffset += 1*1;
  1771.                 }
  1772.     Nextchar1mem: 
  1773.                 i++;
  1774.                 CurrentByteOffset ++;
  1775.             } /* while i < end */
  1776.  
  1777.         return 0;
  1778.     }
  1779. #endif    /*AGREP_POINTER*/
  1780. } /* re */
  1781.  
  1782. int
  1783. r_output (buffer, i, end, j) 
  1784. int i, end, j; 
  1785. CHAR *buffer;
  1786. {
  1787.     int PRINTED = 0;
  1788.     int bp;
  1789.     if(i >= end) return 0;
  1790.     if ((j < 1) || (CurrentByteOffset < 0)) return 0;
  1791.     num_of_matched++;
  1792.     if(COUNT)  return 0;
  1793.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  1794.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  1795.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  1796.         if (agrep_finalfp != NULL)
  1797.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  1798.         else {
  1799.             int outindex;
  1800.             if (prevstring[0] != '\0') {
  1801.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  1802.                     OUTPUT_OVERFLOW;
  1803.                     return -1;
  1804.                 }
  1805.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  1806.             }
  1807.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1808.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  1809.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1810.             }
  1811.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  1812.                 OUTPUT_OVERFLOW;
  1813.                 return -1;
  1814.             }
  1815.             else {
  1816.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  1817.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  1818.             }
  1819.             agrep_outpointer += outindex;
  1820.         }
  1821.         NEW_FILE = OFF;
  1822.         PRINTED = 1;
  1823.     }
  1824.     bp = i-1;
  1825.     while ((buffer[bp] != '\n') && (bp > 0)) bp--;
  1826.     if(LINENUM) {
  1827.         if (agrep_finalfp != NULL)
  1828.             fprintf(agrep_finalfp, "%d: ", j-1); 
  1829.         else {
  1830.             char s[32];
  1831.             int  outindex;
  1832.  
  1833.             sprintf(s, "%d: ", j-1);
  1834.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1835.                     (s[outindex] != '\0'); outindex++) {
  1836.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  1837.             }
  1838.             if (s[outindex] != '\0') {
  1839.                 OUTPUT_OVERFLOW;
  1840.                 return -1;
  1841.             }
  1842.             agrep_outpointer += outindex;
  1843.         }
  1844.         PRINTED = 1;
  1845.     }
  1846.  
  1847.     if(BYTECOUNT) {
  1848.         if (agrep_finalfp != NULL)
  1849.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset);
  1850.         else {
  1851.             char s[32];
  1852.             int  outindex;
  1853.             sprintf(s, "%d= ", CurrentByteOffset);
  1854.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1855.                     (s[outindex] != '\0'); outindex++) {
  1856.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  1857.             }
  1858.             if (s[outindex] != '\0') {
  1859.                 OUTPUT_OVERFLOW;
  1860.                 return -1;
  1861.             }
  1862.             agrep_outpointer += outindex;
  1863.         }
  1864.         PRINTED = 1;
  1865.     }
  1866.  
  1867.     if(buffer[bp] != '\n') bp = Maxline-1;
  1868.     bp++;
  1869.  
  1870.     if (PRINTOFFSET) {
  1871.         if (agrep_finalfp != NULL)
  1872.             fprintf(agrep_finalfp, "@%d{%d} ", CurrentByteOffset - (i-bp), i-bp);
  1873.         else {
  1874.             char s[32];
  1875.             int outindex;
  1876.             sprintf(s, "@%d{%d} ", CurrentByteOffset - (i-bp), i-bp);
  1877.             for (outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1878.                      (s[outindex] != '\0'); outindex ++) {
  1879.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  1880.             }
  1881.             if (s[outindex] != '\0') {
  1882.                 OUTPUT_OVERFLOW;
  1883.                 return -1;
  1884.             }
  1885.             agrep_outpointer += outindex;
  1886.         }
  1887.         PRINTED = 1;
  1888.     }
  1889.     if (PRINTRECORD) {
  1890.     if (agrep_finalfp != NULL)
  1891.         while(bp <= i) fputc(buffer[bp++], agrep_finalfp);
  1892.     else {
  1893.         if (i - bp + 1 + agrep_outpointer >= agrep_outlen) {
  1894.             OUTPUT_OVERFLOW;
  1895.             return -1;
  1896.         }
  1897.         while(bp <= i) agrep_outbuffer[agrep_outpointer ++] = buffer[bp++];
  1898.     }
  1899.     }
  1900.     else if (PRINTED) {
  1901.         if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);
  1902.         else agrep_outbuffer[agrep_outpointer ++] = '\n';
  1903.         PRINTED = 0;
  1904.     }
  1905.  
  1906.     return 0;
  1907. }
  1908.  
  1909. /*
  1910.  * Processes the options specified in argc and argv, and fetches the pattern.
  1911.  * Also sets the set of filenames to be searched for internally. Returns: -1
  1912.  * if there is a serious error, 0 if there is no pattern or an error in getting
  1913.  * the file names, the length (> 0) of the pattern if there is no error. When a
  1914.  * 0 is returned, it means that at least the options were processed correctly.
  1915.  */
  1916. int
  1917. agrep_init(argc, argv, initialfd, pattern_len, pattern_buffer)
  1918.     int    argc;
  1919.     char    *argv[];
  1920.     int    initialfd;
  1921.     int    pattern_len;
  1922.     CHAR    *pattern_buffer;
  1923. {
  1924.     int i, j, seenlsq = 0;
  1925.     char c, *p;
  1926.     int filetype;
  1927.     char **original_argv = argv;
  1928.     char *home;
  1929.     int quitwhile;
  1930.     int NOOUTTAIL=OFF;
  1931.  
  1932.     initial_value();
  1933.  
  1934.     if (pattern_len < 1) {
  1935.         fprintf(stderr, "agrep_init: pattern length %d too small\n", pattern_len);
  1936.         errno = 3;
  1937.         return -1;
  1938.     }
  1939.     agrep_initialfd = initialfd;
  1940.     strncpy(Progname, argv[0], MAXNAME);
  1941.     if (argc < 2) return agrep_usage();
  1942.  
  1943.     Pattern[0] = '\0';
  1944.  
  1945.     while(--argc > 0 && (*++argv)[0] == '-') { /* argv is incremented automatically here */
  1946.         p = argv[0]+1;                 /* ptr to first character after '-' */
  1947.         c = *(argv[0]+1); 
  1948.         quitwhile = OFF;
  1949.         while(!quitwhile && (*p != '\0')) {
  1950.             c = *p;
  1951.             switch(c) {
  1952.             case 'z' :
  1953.                 NOOUTPUTZERO = ON;    /* don't output files with 0 matches */
  1954.                 PRINT(printf("z\n");
  1955.                 )
  1956.                     break;
  1957.  
  1958.             case 'c' : 
  1959.                 COUNT = ON;    /* output the # of matches */
  1960.                 PRINT(printf("c\n");
  1961.                 )
  1962.                     break;
  1963.  
  1964.             case 's' : 
  1965.                 SILENT = ON;   /* silent mode  */
  1966.                 PRINT(printf("s\n");
  1967.                 )
  1968.                     break;
  1969.  
  1970.             case 'p' : 
  1971.                 I = 0;         /* insertion cost is 0 */
  1972.                 PRINT(printf("p\n");
  1973.                 )
  1974.                     break; 
  1975.             case 'P' :
  1976.                 PRINTPATTERN = 1;    /* print pattern before every matched line */
  1977.                 PRINT(printf("p\n");
  1978.                 )
  1979.                     break;
  1980.  
  1981.             case 'x' : 
  1982.                 WHOLELINE = ON;  /* match the whole line */
  1983.                 PRINT(printf("x\n");
  1984.                 )
  1985.                     if(WORDBOUND) {
  1986.                         fprintf(stderr, "%s: illegal option combination (-x and -w)\n", Progname);
  1987.                         if (!EXITONERROR) {
  1988.                             errno = AGREP_ERROR;
  1989.                             return -1;
  1990.                         }
  1991.                         else exit(2);
  1992.                     }
  1993.                 break;
  1994.  
  1995.             case 'b' : 
  1996.                 BYTECOUNT = ON;
  1997.                 PRINT(printf("b\n");
  1998.                 )
  1999.                 break;
  2000.  
  2001.             case 'q' :
  2002.                 PRINTOFFSET = ON;
  2003.                 PRINT(printf("b\n");
  2004.                 )
  2005.                 break;
  2006.  
  2007.             case 'u' :
  2008.                 PRINTRECORD = OFF;
  2009.                 PRINT(printf("u\n");
  2010.                 )
  2011.                 break;
  2012.  
  2013.             case 'g' :
  2014.                 PRINTFILENUMBER = ON;
  2015.                 PRINT(printf("u\n");
  2016.                 )
  2017.                 break;
  2018.  
  2019.             case 'L' :
  2020.                 if ( *(p + 1) == '\0') {/* space after -L option */
  2021.                     if(argc <= 1) {
  2022.                         fprintf(stderr, "%s: the -L option must have an output-limit argument\n", Progname);
  2023.                         if (!EXITONERROR) {
  2024.                             errno = AGREP_ERROR;
  2025.                             return -1;
  2026.                         }
  2027.                         else exit(2);
  2028.                     }
  2029.                     argv++;
  2030.                     LIMITOUTPUT = LIMITTOTALFILE = LIMITPERFILE = 0;
  2031.                     sscanf(argv[0], "%d:%d:%d", &LIMITOUTPUT, &LIMITTOTALFILE, &LIMITPERFILE);
  2032.                     if ((LIMITOUTPUT < 0) || (LIMITTOTALFILE < 0) || (LIMITPERFILE < 0)) {
  2033.                         fprintf(stderr, "%s: invalid output limit %s\n", Progname, argv[0]);
  2034.                         if (!EXITONERROR) {
  2035.                             errno = AGREP_ERROR;
  2036.                             return -1;
  2037.                         }
  2038.                         else exit(2);
  2039.                     }
  2040.                     argc--;
  2041.                 } 
  2042.                 else {
  2043.                     LIMITOUTPUT = LIMITTOTALFILE = LIMITPERFILE = 0;
  2044.                     sscanf(p+1, "%d:%d:%d", &LIMITOUTPUT, &LIMITTOTALFILE, &LIMITPERFILE);
  2045.                     if ((LIMITOUTPUT < 0) || (LIMITTOTALFILE < 0) || (LIMITPERFILE < 0)) {
  2046.                         fprintf(stderr, "%s: invalid output limit %s\n", Progname, p+1);
  2047.                         if (!EXITONERROR) {
  2048.                             errno = AGREP_ERROR;
  2049.                             return -1;
  2050.                         }
  2051.                         else exit(2);
  2052.                     }
  2053.                 } /* else */
  2054.                 PRINT(printf("L\n");
  2055.                 )
  2056.                 quitwhile = ON;
  2057.                 break;
  2058.  
  2059.             case 'd' : 
  2060.                 DELIMITER = ON;  /* user defines delimiter */
  2061.                 PRINT(printf("d\n");
  2062.                 )
  2063.                 if ( *(p + 1) == '\0') {/* space after -d option */
  2064.                     if(argc <= 1) {
  2065.                         fprintf(stderr, "%s: the -d option must have a delimiter argument\n", Progname);
  2066.                         if (!EXITONERROR) {
  2067.                             errno = AGREP_ERROR;
  2068.                             return -1;
  2069.                         }
  2070.                         else exit(2);
  2071.                     }
  2072.                     argv++;
  2073.                     if ((D_length = strlen(argv[0])) > MaxDelimit) {
  2074.                         fprintf(stderr, "%s: delimiter pattern too long (has > %d chars)\n", Progname, MaxDelimit);
  2075.                         if (!EXITONERROR) {
  2076.                             errno = AGREP_ERROR;
  2077.                             return -1;
  2078.                         }
  2079.                         else exit(2);
  2080.                     }
  2081.                     D_pattern[0] = '<';
  2082.                     strcpy(D_pattern+1, argv[0]);
  2083.                     if (((argv[0][D_length-1] == '\n') || (argv[0][D_length-1] == '$') || (argv[0][D_length-1] == '^')) && (D_length == 1))
  2084.                         OUTTAIL = ON;
  2085.                     argc--;
  2086.                     PRINT(printf("space\n");
  2087.                     )
  2088.                 } 
  2089.                 else {
  2090.                     if ((D_length = strlen(p + 1)) > MaxDelimit) {
  2091.                         fprintf(stderr, "%s: delimiter pattern too long (has > %d chars)\n", Progname, MaxDelimit);
  2092.                         if (!EXITONERROR) {
  2093.                             errno = AGREP_ERROR;
  2094.                             return -1;
  2095.                         }
  2096.                         else exit(2);
  2097.                     }
  2098.                     D_pattern[0] = '<';
  2099.                     strcpy(D_pattern+1, p + 1);
  2100.                     if ((((p+1)[D_length-1] == '\n') || ((p+1)[D_length-1] == '$') || ((p+1)[D_length-1] == '^')) && (D_length == 1))
  2101.                         OUTTAIL = ON;
  2102.                 } /* else */
  2103.                 strcat(D_pattern, ">; ");
  2104.                 D_length++;   /* to count '<' as one */
  2105.                 PRINT(printf("D_pattern=%s\n", D_pattern);
  2106.                 )
  2107.                 strcpy(original_D_pattern, D_pattern);
  2108.                 original_D_length = D_length;
  2109.                 quitwhile = ON;
  2110.                 break;
  2111.  
  2112.             case 'H':
  2113.                 if (*(p + 1) == '\0') {/* space after - option */
  2114.                     if (argc <= 1) {
  2115.                         fprintf(stderr, "%s: a directory name must follow the -H option\n", Progname);
  2116.                         if (!EXITONERROR) {
  2117.                             errno = AGREP_ERROR;
  2118.                             return agrep_usage();
  2119.                         }
  2120.                         else exit(2);
  2121.                     }
  2122.                     argv ++;
  2123.                     strcpy(COMP_DIR, argv[0]);
  2124.                     argc --;
  2125.                 }
  2126.                 else {
  2127.                     strcpy(COMP_DIR, p+1);
  2128.                 }
  2129.                 quitwhile = ON;
  2130.                 break;
  2131.  
  2132.             case 'e' : 
  2133.                 if ( *(p + 1) == '\0') {/* space after -e option */
  2134.                     if(argc <= 1) {
  2135.                         fprintf(stderr, "%s: the -e option must have a pattern argument\n", Progname);
  2136.                         if (!EXITONERROR) {
  2137.                             errno = AGREP_ERROR;
  2138.                             return -1;
  2139.                         }
  2140.                         else exit(2);
  2141.                     }
  2142.                     argv++;
  2143.                     if(argv[0][0] == '-') {    /* not strictly necessary but no harm done */
  2144.                         Pattern[0] = '\\';
  2145.                         strcat(Pattern, (argv)[0]);
  2146.                     }
  2147.                     else strcat(Pattern, argv[0]);
  2148.                     argc--;
  2149.                 }
  2150.                 else {
  2151.                     if (*(p+1) == '-') {    /* not strictly necessary but no harm done */
  2152.                         Pattern[0] = '\\';
  2153.                         strcat(Pattern, p+1);
  2154.                     }
  2155.                     else strcat (Pattern, p+1);
  2156.                 } /* else */
  2157.  
  2158.                 PRINT(printf("Pattern=%s\n", Pattern);
  2159.                 )
  2160.                 pattern_index = abs(argv - original_argv);
  2161.                 quitwhile = ON;
  2162.                 break;
  2163.  
  2164.             case 'k' : 
  2165.                 CONSTANT = ON;
  2166.                 if ( *(p + 1) == '\0') {/* space after -e option */
  2167.                     if(argc <= 1) {
  2168.                         fprintf(stderr, "%s: the -k option must have a pattern argument\n", Progname);
  2169.                         if (!EXITONERROR) {
  2170.                             errno = AGREP_ERROR;
  2171.                             return -1;
  2172.                         }
  2173.                         else exit(2);
  2174.                     }
  2175.                     argv++;
  2176.                     strcat(Pattern, argv[0]);
  2177.                     if((argc > 2) && (argv[1][0] == '-')) {
  2178.                         fprintf(stderr, "%s: -k should be the last option in the command\n", Progname);
  2179.                         if (!EXITONERROR) {
  2180.                             errno = AGREP_ERROR;
  2181.                             return -1;
  2182.                         }
  2183.                         else exit(2);
  2184.                     }
  2185.                     argc--;
  2186.                 }
  2187.                 else {
  2188.                     if((argc > 1) && (argv[1][0] == '-')) {
  2189.                         fprintf(stderr, "%s: -k should be the last option in the command\n", Progname);
  2190.                         if (!EXITONERROR) {
  2191.                             errno = AGREP_ERROR;
  2192.                             return -1;
  2193.                         }
  2194.                         else exit(2);
  2195.                     }
  2196.                     strcat (Pattern, p+1);
  2197.                 } /* else */
  2198.  
  2199.                 pattern_index = abs(argv - original_argv);
  2200.                 quitwhile = ON;
  2201.                 break;
  2202.  
  2203.             case 'f' : 
  2204.                 if (PAT_FILE == ON) {
  2205.                     fprintf(stderr, "%s: multiple -f options\n", Progname);
  2206.                     if (multifd >= 0) close(multifd);
  2207.                     if (!EXITONERROR) {
  2208.                         errno = AGREP_ERROR;
  2209.                         return -1;
  2210.                     }
  2211.                     else exit(2);
  2212.                 }
  2213.                 if (PAT_BUFFER == ON) {
  2214.                     fprintf(stderr, "%s: -f and -m are incompatible\n", Progname);
  2215.                     if (multibuf != NULL) free(multibuf);
  2216.                     multibuf = NULL;
  2217.                     multilen = 0;
  2218.                     if (!EXITONERROR) {
  2219.                         errno = AGREP_ERROR;
  2220.                         return -1;
  2221.                     }
  2222.                     else exit(2);
  2223.                 }
  2224.                 PAT_FILE = ON;
  2225.                 PRINT(printf("f\n");
  2226.                 )
  2227.                 argv++;
  2228.                 argc--;
  2229.  
  2230.                 if (argv[0] == NULL) {
  2231.                     /* A -f option with a NULL file name is a NO-OP: stupid, but simplifies glimpse :-) */
  2232.                     PAT_FILE = OFF;
  2233.                     quitwhile = ON;
  2234.                     break;
  2235.                 }
  2236.  
  2237.                 if((multifd = open(argv[0], O_RDONLY)) < 0) {
  2238.                     PAT_FILE = OFF;
  2239.                     fprintf(stderr, "%s: can't open pattern file for reading: %s\n", Progname, argv[0]);
  2240.                     if (!EXITONERROR) {
  2241.                         errno = AGREP_ERROR;
  2242.                         return -1;
  2243.                     }
  2244.                     else exit(2);
  2245.                 }
  2246.                 PRINT(printf("file=%s\n", argv[0]);
  2247.                 )
  2248.                 strcpy(PAT_FILE_NAME, argv[0]);
  2249.                 if (prepf(multifd, NULL, 0) <= -1) {
  2250.                     close(multifd);
  2251.                     PAT_FILE = OFF;
  2252.                     fprintf(stderr, "%s: error in processing pattern file: %s\n", Progname, argv[0]);
  2253.                     if (!EXITONERROR) {
  2254.                         errno = AGREP_ERROR;
  2255.                         return -1;
  2256.                     }
  2257.                     else exit(2);
  2258.                 }
  2259.                 quitwhile = ON;
  2260.                 break;
  2261.  
  2262.             case 'm' :
  2263.                 if (PAT_BUFFER == ON) {
  2264.                     fprintf(stderr, "%s: multiple -m options\n", Progname);
  2265.                     if (multibuf != NULL) free(multibuf);
  2266.                     multilen = 0;
  2267.                     if (!EXITONERROR) {
  2268.                         errno = AGREP_ERROR;
  2269.                         return -1;
  2270.                     }
  2271.                     else exit(2);
  2272.                 }
  2273.                 if (PAT_FILE == ON) {
  2274.                     fprintf(stderr, "%s: -f and -m are incompatible\n", Progname);
  2275.                     if (multifd >= 0) close(multifd);
  2276.                     if (!EXITONERROR) {
  2277.                         errno = AGREP_ERROR;
  2278.                         return -1;
  2279.                     }
  2280.                     else exit(2);
  2281.                 }
  2282.                 PAT_BUFFER = ON;
  2283.                 PRINT(printf("m\n");
  2284.                 )
  2285.                 argv ++;
  2286.                 argc --;
  2287.  
  2288.  
  2289.                 if ((argv[0] == NULL) || ((multilen = strlen(argv[0])) <= 0)) {
  2290.                     /* A -m option with a NULL or empty pattern buffer is a NO-OP: stupid, but simplifies glimpse :-) */
  2291.                     PAT_BUFFER = OFF;
  2292.                     multilen = 0;
  2293.                     multibuf = NULL;
  2294.                 }
  2295.                 else {
  2296.                     multibuf = (char *)malloc(multilen + 2);
  2297.                     strcpy(multibuf, argv[0]);
  2298.                     PRINT(printf("patterns=%s\n", multibuf);
  2299.                     )
  2300.                     if (prepf(-1, multibuf, multilen) <= -1) {
  2301.                         free(multibuf);
  2302.                         multilen = 0;
  2303.                         PAT_BUFFER = OFF;
  2304.                         fprintf(stderr, "%s: error in processing pattern buffer\n", Progname);
  2305.                         if (!EXITONERROR) {
  2306.                             errno = AGREP_ERROR;
  2307.                             return -1;
  2308.                         }
  2309.                         else exit(2);
  2310.                     }
  2311.                 }
  2312.                 quitwhile = ON;
  2313.                 break;
  2314.  
  2315.             case 'h' : 
  2316.                 NOFILENAME = ON;
  2317.                 PRINT(printf("h\n");
  2318.                 )
  2319.                     break;
  2320.  
  2321.             case 'i' : 
  2322.                 NOUPPER = ON;
  2323.                 PRINT(printf("i\n");
  2324.                 )
  2325.                     break;
  2326.  
  2327.             case 'l' : 
  2328.                 FILENAMEONLY = ON;
  2329.                 PRINT(printf("l\n");
  2330.                 )
  2331.                     break;
  2332.  
  2333.             case 'n' : 
  2334.                 LINENUM = ON;  /* output prefixed by line no*/
  2335.                 PRINT(printf("n\n");
  2336.                 )
  2337.                     break;
  2338.  
  2339.             case 'r' : 
  2340.                 RECURSIVE = ON;
  2341.                 PRINT(printf("r\n");
  2342.                 )
  2343.                     break;
  2344.             
  2345.             case 'V' :
  2346.                 printf("\nThis is agrep version %s, %s.\n\n", AGREP_VERSION, AGREP_DATE);
  2347.                 return 0;
  2348.  
  2349.             case 'v' : 
  2350.                 INVERSE = ON;  /* output no-matched lines */
  2351.                 PRINT(printf("v\n");
  2352.                 )
  2353.                     break;
  2354.  
  2355.             case 't' : 
  2356.                 OUTTAIL = ON;  /* output from tail of delimiter */
  2357.                 PRINT(printf("t\n");
  2358.                 )
  2359.                     break;
  2360.  
  2361.             case 'o' : 
  2362.                 NOOUTTAIL = ON;  /* output from front of delimiter */
  2363.                 PRINT(printf("t\n");
  2364.                 )
  2365.                     break;
  2366.  
  2367.             case 'B' : 
  2368.                 BESTMATCH = ON;
  2369.                 PRINT(printf("B\n");
  2370.                 )
  2371.                     break;
  2372.  
  2373.             case 'w' : 
  2374.                 WORDBOUND = ON;/* match to words */
  2375.                 PRINT(printf("w\n");
  2376.                 )
  2377.                     if(WHOLELINE) {
  2378.                         fprintf(stderr, "%s: illegal option combination (-w and -x)\n", Progname);
  2379.                         if (!EXITONERROR) {
  2380.                             errno = AGREP_ERROR;
  2381.                             return -1;
  2382.                         }
  2383.                         else exit(2);
  2384.                     }
  2385.                 break;
  2386.  
  2387.             case 'y' : 
  2388.                 NOPROMPT = ON;
  2389.                 PRINT(printf("y\n");
  2390.                 )
  2391.                     break;
  2392.  
  2393.             case 'I' : 
  2394.                 I = atoi(p + 1);  /* Insertion Cost */
  2395.                 JUMP = ON;
  2396.                 quitwhile = ON;
  2397.                 break;
  2398.  
  2399.             case 'S' : 
  2400.                 S = atoi(p + 1);  /* Substitution Cost */
  2401.                 JUMP = ON;
  2402.                 quitwhile = ON;
  2403.                 break;
  2404.  
  2405.             case 'D' : 
  2406.                 DD = atoi(p + 1); /* Deletion Cost */
  2407.                 JUMP = ON;
  2408.                 quitwhile = ON;
  2409.                 break;
  2410.  
  2411.             case 'G' : 
  2412.                 FILEOUT = ON; 
  2413.                 COUNT = ON;
  2414.                 break;
  2415.  
  2416.             case 'A':
  2417.                 ALWAYSFILENAME = ON;
  2418.                 break;
  2419.  
  2420.             case 'O':
  2421.                 POST_FILTER = ON;
  2422.  
  2423.             case 'M':
  2424.                 MULTI_OUTPUT = ON;
  2425.  
  2426.             case 'Z': break;    /* no-op: used by glimpse */
  2427.             
  2428.             default  : 
  2429.                 if (isdigit(c)) {
  2430.                     APPROX = ON;
  2431.                     D = atoi(p);
  2432.                     if (D > MaxError) {
  2433.                         fprintf(stderr,"%s: the maximum number of errors is %d\n", Progname, MaxError);
  2434.                         if (!EXITONERROR) {
  2435.                             errno = AGREP_ERROR;
  2436.                             return -1;
  2437.                         }
  2438.                         else exit(2);
  2439.                     }
  2440.                     quitwhile = ON;    /* note that even a number should occur at the end of a group of options, as f & e */
  2441.                 }
  2442.                 else {
  2443.                     fprintf(stderr, "%s: illegal option  -%c\n",Progname, c);
  2444.                     return agrep_usage();
  2445.                 }
  2446.  
  2447.             } /* switch(c) */
  2448.             p ++;
  2449.         }
  2450.     } /* while (--argc > 0 && (*++argv)[0] == '-') */
  2451.  
  2452.     if (NOOUTTAIL == ON) OUTTAIL = OFF;
  2453.  
  2454.     if (COMP_DIR[0] == '\0') {
  2455.         if ((home = (char *)getenv("HOME")) == NULL) {
  2456.             getcwd(COMP_DIR, MAX_LINE_LEN-1);
  2457.             fprintf(stderr, "using working-directory '%s' to locate dictionaries\n", COMP_DIR);
  2458.         }
  2459.         else strncpy(COMP_DIR, home, MAX_LINE_LEN);
  2460.     }
  2461.  
  2462.     strcpy(FREQ_FILE, COMP_DIR);
  2463.     strcat(FREQ_FILE, "/");
  2464.     strcat(FREQ_FILE, DEF_FREQ_FILE);
  2465.     strcpy(HASH_FILE, COMP_DIR);
  2466.     strcat(HASH_FILE, "/");
  2467.     strcat(HASH_FILE, DEF_HASH_FILE);
  2468.     strcpy(STRING_FILE, COMP_DIR);
  2469.     strcat(STRING_FILE, "/");
  2470.     strcat(STRING_FILE, DEF_STRING_FILE);
  2471.     initialize_common(FREQ_FILE, 0);    /* no error msgs */
  2472.  
  2473.     if (FILENAMEONLY && NOFILENAME) {
  2474.         fprintf(stderr, "%s: -h and -l options are mutually exclusive\n",Progname);
  2475.     }
  2476.     if (COUNT && (FILENAMEONLY || NOFILENAME)) {
  2477.         FILENAMEONLY = OFF; 
  2478.         if(!FILEOUT) NOFILENAME = OFF;
  2479.     }
  2480.  
  2481.     if (!(PAT_FILE || PAT_BUFFER) && Pattern[0] == '\0') { /* Pattern not set with -e option */
  2482.         if (argc <= 0) {
  2483.             agrep_usage();
  2484.             return 0;
  2485.         }
  2486.         strcpy(Pattern, *argv); 
  2487.         pattern_index = abs(argv - original_argv);
  2488.         argc--;
  2489.         argv++;
  2490.     }
  2491.     /* if multi-pattern search, just ignore any specified pattern altogether: treat it as a filename */
  2492.  
  2493.     if (copied_from_argv) {
  2494.         for (i=0; i<Numfiles; i++) free(Textfiles[i]);
  2495.         if (Textfiles != NULL) free(Textfiles);
  2496.     }
  2497.     copied_from_argv = 0;
  2498.     Numfiles = 0; Textfiles = NULL;
  2499.     execfd = agrep_initialfd;
  2500.     if (argc <= 0)  /* check Pattern against stdin */
  2501.         execfd = 0;
  2502.     else {    /* filenames were specified as a part of the command line */
  2503.         if (!(Textfiles = (CHAR **)malloc(argc * sizeof(CHAR *) ))) {
  2504.             fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2505.             if (!EXITONERROR) {
  2506.                 errno = AGREP_ERROR;
  2507.                 return 0;
  2508.             }
  2509.             else exit(2);
  2510.         }
  2511.         copied_from_argv = 1;    /* should I free Textfiles next time? */
  2512.         while (argc--)
  2513.         {    /* one or more filenames on command line -- put the valid filenames in a array of strings */
  2514.  
  2515.             if ((filetype = check_file(*argv)) == NOSUCHFILE) {
  2516.                 if (!glimpse_call) if (!glimpse_call) fprintf(stderr,"%s: '%s' no such file or directory\n",Progname,*argv);
  2517.                 argv++;
  2518.             }
  2519.             else { /* file is ascii*/
  2520.                 if (!(Textfiles[Numfiles] = (CHAR *)malloc((strlen(*argv)+2)))) {
  2521.                     fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2522.                     if (!EXITONERROR) {
  2523.                         errno = AGREP_ERROR;
  2524.                         return 0;
  2525.                     }
  2526.                     else exit(2);
  2527.                 }
  2528.                 strcpy(Textfiles[Numfiles++], *argv++);
  2529.             } /* else */
  2530.         } /* while (argc--) */
  2531.         if (Numfiles <= 0) return 0;
  2532.         /* If user specified wrong filenames, then we quit rather than taking input from stdin! */
  2533.     } /* else */
  2534.  
  2535.     M = strlen(Pattern);
  2536.     if (M<=0) return 0;
  2537.     for (i=0; i<M; i++) {
  2538.         if (( ((unsigned char *)Pattern)[i] > USERRANGE_MIN) && ( ((unsigned char *)Pattern)[i] <= USERRANGE_MAX)) {
  2539.             fprintf(stderr, "Warning: pattern has some meta-characters interpreted by agrep!\n");
  2540.             break;
  2541.         }
  2542.         else if (Pattern[i] == '\\') i++;    /* extra */
  2543.         else if (Pattern[i] == '[') seenlsq = 1;
  2544.         else if ((Pattern[i] == '-') && !seenlsq) {
  2545.             for (j=M; j>=i; j--)
  2546.                 Pattern[j+1] = Pattern[j];    /* right shift including '\0' */
  2547.             Pattern[i] = '\\';    /* escape the - */
  2548.             M ++;
  2549.             i++;
  2550.         }
  2551.         else if (Pattern[i] == ']') seenlsq = 0;
  2552.     }
  2553.  
  2554.     if (M > pattern_len - 1) {
  2555.         fprintf(stderr, "%s: pattern '%s' does not fit in specified buffer\n", Progname, Pattern);
  2556.         errno = 3;
  2557.         return 0;
  2558.     }
  2559.     if (pattern_buffer != Pattern)    /* not from mem/file-agrep() */
  2560.         strncpy(pattern_buffer, Pattern, M+1); /* copy \0 */
  2561.     return M;
  2562. }
  2563.  
  2564. /*
  2565.  * User need not bother about initialfd.
  2566.  * Both functions return -1 on error, 0 if there was no pattern,
  2567.  * length (>=1) of pattern otherwise.
  2568.  */
  2569.  
  2570. int
  2571. memagrep_init(argc, argv, pattern_len, pattern_buffer)
  2572.     int    argc;
  2573.     char    *argv[];
  2574.     int    pattern_len;
  2575.     char    *pattern_buffer;
  2576. {
  2577.     return (agrep_init(argc, argv, -1, pattern_len, pattern_buffer));
  2578. }
  2579.  
  2580. int
  2581. fileagrep_init(argc, argv, pattern_len, pattern_buffer)
  2582.     int    argc;
  2583.     char    *argv[];
  2584.     int    pattern_len;
  2585.     char    *pattern_buffer;
  2586. {
  2587.     return (agrep_init(argc, argv, 3, pattern_len, pattern_buffer));
  2588. }
  2589.  
  2590. /* returns -1 on error, num of matches (>=0) otherwise */
  2591. int
  2592. agrep_search(pattern_len, pattern_buffer, initialfd, input_len, input, output_len, output)
  2593. int pattern_len; 
  2594. CHAR *pattern_buffer;
  2595. int initialfd;
  2596. int input_len;
  2597. void *input;
  2598. int output_len;
  2599. void *output;
  2600. {
  2601.     int    i;
  2602.     int    filetype;
  2603.     int    ret;
  2604.     int    pattern_has_changed = 1;
  2605.  
  2606.     if ((multifd == -1) && (multibuf == NULL) && (pattern_len < 1)) {
  2607.         fprintf(stderr, "%s: pattern length %d too small\n", Progname, pattern_len);
  2608.         errno = 3;
  2609.         return -1;
  2610.     }
  2611.     if (pattern_len >= MAXPAT) {
  2612.         fprintf(stderr, "%s: pattern '%s' too long\n", Progname, pattern_buffer);
  2613.         errno = 3;
  2614.         return -1;
  2615.     }
  2616.  
  2617.     /* courtesy: crd@hplb.hpl.hp.com */
  2618.     if (agrep_saved_pattern) {
  2619.         if (strcmp(agrep_saved_pattern, pattern_buffer)) {
  2620.             free(agrep_saved_pattern);
  2621.             agrep_saved_pattern = NULL;
  2622.         }
  2623.         else {
  2624.             pattern_has_changed = 0;
  2625.         }
  2626.     }
  2627.     if (! agrep_saved_pattern) {
  2628.         agrep_saved_pattern = (CHAR *)malloc(pattern_len+1);
  2629.         memcpy(agrep_saved_pattern, pattern_buffer, pattern_len);
  2630.         agrep_saved_pattern[pattern_len] = '\0';
  2631.  
  2632.     }
  2633.     if (!pattern_has_changed) {
  2634.         reinit_value_partial();
  2635.     }
  2636.     else {
  2637.         reinit_value();
  2638.         if (pattern_buffer != Pattern)    /* not from mem/file-agrep() */
  2639.             strncpy(Pattern, pattern_buffer, pattern_len+1); /* copy \0 */
  2640.         M = strlen(Pattern);
  2641.     }
  2642.  
  2643.     if (output == NULL) {
  2644.         fprintf(stderr, "%s: invalid output descriptor\n", Progname);
  2645.         return -1;
  2646.     }
  2647.     if (output_len <= 0) {
  2648.         agrep_finalfp = (FILE *)output;
  2649.         agrep_outlen = 0;
  2650.         agrep_outbuffer = NULL;
  2651.         agrep_outpointer = 0;
  2652.     }
  2653.     else {
  2654.         agrep_finalfp = NULL;
  2655.         agrep_outlen = output_len;
  2656.         agrep_outbuffer = (CHAR *)output;
  2657.         agrep_outpointer = 0;
  2658.     }
  2659.  
  2660.     agrep_initialfd = initialfd;
  2661.     execfd = initialfd;
  2662.     if (initialfd == -1) {
  2663.         agrep_inbuffer = (CHAR *)input;
  2664.         agrep_inlen = input_len;
  2665.         agrep_inpointer = 0;
  2666.     }
  2667.     else if ((input_len > 0) && (input != NULL)) {
  2668.         /* Copy the set of filenames into Textfiles */
  2669.         if (copied_from_argv) {
  2670.             for (i=0; i<Numfiles; i++) free(Textfiles[i]);
  2671.             if (Textfiles != NULL) free(Textfiles);
  2672.         }
  2673.         copied_from_argv = 0;
  2674.         Numfiles = 0; Textfiles = NULL;
  2675. #if    0
  2676.         if (!(Textfiles = (CHAR **)malloc(input_len * sizeof(CHAR *) ))) {
  2677.             fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2678.             if (!EXITONERROR) {
  2679.                 errno = AGREP_ERROR;
  2680.                 return 0;
  2681.             }
  2682.             else exit(2);
  2683.         }
  2684. #else    /*0*/
  2685.         Textfiles = (CHAR **)input;
  2686. #endif    /*0*/
  2687.  
  2688.         while (input_len --)
  2689.         {    /* one or more filenames on command line -- put the valid filenames in a array of strings */
  2690.  
  2691.             if ((filetype = check_file(*(char **)input)) == NOSUCHFILE) {
  2692.                 if(filetype == NOSUCHFILE) if (!glimpse_call) fprintf(stderr,"%s: '%s' no such file or directory\n",Progname,*(char **)input);
  2693.                 input = (void *)(((long)input) + sizeof(char *));
  2694.             } 
  2695.             else { /* file is ascii*/
  2696. #if    0
  2697.                 if (!(Textfiles[Numfiles] = (CHAR *)malloc((strlen(*(char **)input)+2)))) {
  2698.                     fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2699.                     if (!EXITONERROR) {
  2700.                         errno = AGREP_ERROR;
  2701.                         return 0;
  2702.                     }
  2703.                     else exit(2);
  2704.                 }
  2705.                 strcpy(Textfiles[Numfiles++], *((char **)input));
  2706. #else    /*0*/
  2707.                 Textfiles[Numfiles++] = *((CHAR **)input);
  2708. #endif    /*0*/
  2709.                 input = (void *)(((long)input) + sizeof(char *));
  2710.             } /* else */
  2711.         } /* while (argc--) */
  2712.         if (Numfiles <= 0) return 0;
  2713.         /* If user specified wrong filenames, then we quit rather than taking input from stdin! */
  2714.     }
  2715.     else if (Numfiles <= 0) execfd = 0;
  2716.     /* the old set of files (agrep_init) are used */
  2717.  
  2718. #if    0
  2719.     printf("agrep_search: pat=%s buf=%s\n", Pattern, ((agrep_initialfd == -1) && (agrep_inlen < 20)) ? agrep_inbuffer : NULL);
  2720. #endif    /*0*/
  2721.  
  2722.     if (pattern_has_changed) {
  2723.         if (-1 == checksg(Pattern, D, 1)) return -1;       /* check if the pattern is simple */
  2724.         strcpy(OldPattern, Pattern);
  2725.  
  2726.         if (SGREP == 0) {    /* complex pattern search */
  2727.             if (-1 == preprocess(D_pattern, Pattern)) return -1;
  2728.             strcpy(old_D_pat, D_pattern);
  2729.             /* fprintf(stderr, "agrep_search: len=%d pat=%s\n", strlen(Pattern), Pattern); */
  2730.             if(!AParse &&  ((M = maskgen(Pattern, D)) == -1)) return -1;
  2731.         }
  2732.         else {    /* sgrep too can handle delimiters */
  2733.             if (DELIMITER) {
  2734.                 /* D_pattern is "<PAT>; ", D_length is 1 + length of string PAT: see agrep.c/'d' */
  2735.                 preprocess_delimiter(D_pattern+1, D_length - 1, D_pattern, &D_length);
  2736.                 /* D_pattern is the exact stuff we want to match, D_length is its strlen */
  2737.                 if ((tc_D_length = quick_tcompress(FREQ_FILE,HASH_FILE,D_pattern,D_length,tc_D_pattern,MaxDelimit*2,TC_EASYSEARCH)) <= 0) {
  2738.                     strcpy(tc_D_pattern, D_pattern);
  2739.                     tc_D_length = D_length;
  2740.                 }
  2741.                 /* printf("sgrep's delim=%s,%d tc_delim=%s,%d\n", D_pattern, D_length, tc_D_pattern, tc_D_length); */
  2742.             }
  2743.             M = strlen(OldPattern);
  2744.         }
  2745.     }
  2746.  
  2747.     if (AParse)  {    /* boolean converted to multi-pattern search */
  2748.         int prepf_ret= 0;
  2749.         if (pattern_has_changed)
  2750.             prepf_ret= prepf(-1, multibuf, multilen);
  2751.         if (prepf_ret  <= -1) {
  2752.             if (AComplexBoolean) destroy_tree(AParse);
  2753.             AParse = 0;
  2754.             PAT_BUFFER = 0;
  2755.             if (multibuf != NULL) free(multibuf);    /* this was allocated for arbit booleans, not multipattern search */
  2756.             multilen = 0;
  2757.             /* Cannot free multifd here since that is always allocated for multipattern search */
  2758.             return -1;
  2759.         }
  2760.     }
  2761.     if (Numfiles > 1) FNAME = ON;
  2762.     if (NOFILENAME) FNAME = 0;
  2763.     if (ALWAYSFILENAME) FNAME = ON;    /* used by glimpse ONLY: 15/dec/93 */
  2764.  
  2765.     if (agrep_initialfd == -1) ret = exec(execfd, NULL);
  2766.     else if(RECURSIVE) ret = (recursive(Numfiles, Textfiles));
  2767.     else  ret = (exec(execfd, Textfiles));
  2768.     return ret;
  2769. }
  2770.  
  2771. /*
  2772.  * User need not bother about initialfd.
  2773.  * Both functions return -1 on error, 0 otherwise.
  2774.  */
  2775.  
  2776. int
  2777. memagrep_search(pattern_len, pattern_buffer, input_len, input_buffer, output_len, output)
  2778. int pattern_len;
  2779. char *pattern_buffer;
  2780. int input_len;
  2781. char *input_buffer;
  2782. int output_len;
  2783. void *output;
  2784. {
  2785.     return(agrep_search(pattern_len, pattern_buffer, -1, input_len, input_buffer, output_len, output));
  2786. }
  2787.  
  2788. int
  2789. fileagrep_search(pattern_len, pattern_buffer, file_num, file_buffer, output_len, output)
  2790. int pattern_len;
  2791. char *pattern_buffer;
  2792. int file_num;
  2793. char **file_buffer;
  2794. int output_len;
  2795. void *output;
  2796. {
  2797.     return(agrep_search(pattern_len, pattern_buffer, 3, file_num, file_buffer, output_len, output));
  2798. }
  2799.  
  2800. /*
  2801.  * The original agrep_run() routine was split into agrep_search and agrep_init
  2802.  * so that the interface with glimpse could be made cleaner: see glimpse.
  2803.  * Now, the user can specify an initial set of options, and use them in future
  2804.  * searches. If agrep_init does not find the pattern, options are still SET.
  2805.  * In fileagrep_search, the user can specify a NEW set of files to be searched
  2806.  * after the options are processed (this is used in glimpse).
  2807.  *
  2808.  * Both functions return -1 on error, 0 otherwise.
  2809.  *
  2810.  * The arguments are self explanatory. The pattern should be specified in
  2811.  * one of the argvs. Options too can be specified in one of the argvs -- it
  2812.  * is exactly as if the options are being given to agrep at run time.
  2813.  * The only restrictions are that the input_buffer should begin with a '\n'
  2814.  * and after its end, there must be valid memory to store a copy of the pattern.
  2815.  */
  2816.  
  2817. int
  2818. memagrep(argc, argv, input_len, input_buffer, output_len, output)
  2819. int argc; 
  2820. char *argv[];
  2821. int input_len;
  2822. char *input_buffer;
  2823. int output_len;
  2824. void *output;
  2825. {
  2826.     int    ret;
  2827.  
  2828.     if ((ret = memagrep_init(argc, argv, MAXPAT, Pattern)) < 0) return -1;
  2829.     else if ((ret == 0) && (multifd == -1) && (multibuf == NULL)) return -1;
  2830.     /* ^^^ because one need not specify the pattern on the cmd line if -f OR -m */
  2831.     return memagrep_search(ret, Pattern, input_len, input_buffer, output_len, output);
  2832. }
  2833.  
  2834. int
  2835. fileagrep(argc, argv, output_len, output)
  2836. int argc; 
  2837. char *argv[];
  2838. int output_len;
  2839. void *output;
  2840. {
  2841.     int    ret;
  2842.  
  2843.     if ((ret = fileagrep_init(argc, argv, MAXPAT, Pattern)) < 0) return -1;
  2844.     else if ((ret == 0) && (multifd == -1) && (multibuf == NULL)) return -1;
  2845.     /* ^^^ because one need not specify the pattern on the cmd line if -f OR -m */
  2846.     return fileagrep_search(ret, Pattern, 0, NULL, output_len, output);
  2847. }
  2848.  
  2849. /*
  2850.  * RETURNS: total number of matched lines in all files that were searched.
  2851.  *
  2852.  * The pattern(s) remain(s) constant irrespective of the number of files.
  2853.  * Hence, essentially, all the interface routines below have to be changed
  2854.  * so that they DONT do that preprocessing again and again for multiple
  2855.  * files. This bug was found while interfacing agrep with cast.
  2856.  *
  2857.  * At present, sgrep() has been modified to have another parameter,
  2858.  * "samepattern" that tells it whether the pattern is the same as before.
  2859.  * Other funtions too should have such a parameter and should not repeat
  2860.  * preprocessing for all patterns. Since preprocessing for a pattern to
  2861.  * be searched in compressed files is siginificant, this bug was found.
  2862.  *
  2863.  * - bgopal on 15/Nov/93.
  2864.  */
  2865. int
  2866. exec(fd, file_list)
  2867. int fd;
  2868. char **file_list;
  2869. { 
  2870.     int i;
  2871.     char c[8];
  2872.     int ret = 0;    /* no error */
  2873.  
  2874.     if ((Numfiles > 1) && (NOFILENAME == OFF)) FNAME = ON;
  2875.     if ((-1 == compat())) return -1; /* check compatibility between options */
  2876.  
  2877.     if (fd <= 0) {
  2878.         TCOMPRESSED = ON;    /* there is a possibility that the data might be tuncompressible */
  2879.         if (!SetCurrentByteOffset) CurrentByteOffset = 0;
  2880.         if((fd == 0) && FILENAMEONLY) {
  2881.             fprintf(stderr, "%s: -l option is not compatible with standard input\n", Progname);
  2882.             if (!EXITONERROR) {
  2883.                 errno = AGREP_ERROR;
  2884.                 return -1;
  2885.             }
  2886.             else exit(2);  
  2887.         }
  2888.         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  2889.         else {
  2890.             if(SGREP) ret = sgrep(OldPattern, strlen(OldPattern), fd, D, 0);
  2891.             else      ret = bitap(old_D_pat, Pattern, fd, M, D);
  2892.         }
  2893.         if (ret <= -1) return -1;
  2894.         if (COUNT && ret) {    /* dirty solution for glimpse's -b! */
  2895.             if(INVERSE && (PAT_FILE || PAT_BUFFER)) {    /* inverse will never be set in glimpse */
  2896.                 if (agrep_finalfp != NULL)
  2897.                     fprintf(agrep_finalfp, "%d\n", total_line-(num_of_matched - prev_num_of_matched));
  2898.                 else {
  2899.                     char s[32];
  2900.                     int  outindex;
  2901.  
  2902.                     sprintf(s, "%d\n", total_line-(num_of_matched - prev_num_of_matched));
  2903.  
  2904.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2905.                             (s[outindex] != '\0'); outindex++) {
  2906.                         agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2907.                     }
  2908.                     if (s[outindex] != '\0') {
  2909.                         OUTPUT_OVERFLOW;
  2910.                         return -1;
  2911.                     }
  2912.                     agrep_outpointer += outindex;
  2913.                 }
  2914.             }
  2915.             else {
  2916.                 if (agrep_finalfp != NULL)
  2917.                     fprintf(agrep_finalfp, "%d\n", (num_of_matched - prev_num_of_matched));
  2918.                 else {
  2919.                     char s[32];
  2920.                     int  outindex;
  2921.  
  2922.                     sprintf(s, "%d\n", (num_of_matched - prev_num_of_matched));
  2923.  
  2924.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2925.                             (s[outindex] != '\0'); outindex++) {
  2926.                         agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2927.                     }
  2928.                     if (s[outindex] != '\0') {
  2929.                         OUTPUT_OVERFLOW;
  2930.                         return -1;
  2931.                     }
  2932.                     agrep_outpointer += outindex;
  2933.                 }
  2934.             }
  2935.         }
  2936.     }
  2937.     else {
  2938.         /* fd > 0 => Numfiles > 0 */
  2939.  
  2940.         for (i = 0; i < Numfiles; i++, close(fd)) {
  2941.             prev_num_of_matched = num_of_matched;
  2942.             if (!SetCurrentByteOffset) CurrentByteOffset = 0;
  2943.             if (!SetCurrentFileName) {
  2944.                 if (PRINTFILENUMBER) sprintf(CurrentFileName, "%d", i);
  2945.                 else strcpy(CurrentFileName, file_list[i]);
  2946.             }
  2947.             TCOMPRESSED = ON;
  2948.             if (!tuncompressible_filename(file_list[i], strlen(file_list[i]))) TCOMPRESSED = OFF;
  2949.             NEW_FILE = ON;
  2950.             if ((fd = open(file_list[i], O_RDONLY)) < /*=*/ 0) {
  2951.                 fprintf(stderr, "%s: can't open file for reading: %s\n",Progname, file_list[i]);
  2952.             } 
  2953.             else { 
  2954.                 if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  2955.                 else {
  2956.                     if(SGREP) ret = sgrep(OldPattern, strlen(OldPattern), fd, D, i);
  2957.                     else      ret = bitap(old_D_pat, Pattern, fd, M, D);
  2958.                 }
  2959.                 if (ret <= -1) {
  2960.                     close(fd);
  2961.                     return -1;
  2962.                 }
  2963.                 if (num_of_matched - prev_num_of_matched > 0) {
  2964.                     NOMATCH = OFF;
  2965.                     files_matched ++;
  2966.                 }
  2967.  
  2968.                 if (COUNT && !FILEOUT) {
  2969.                     if( (INVERSE && (PAT_FILE || PAT_BUFFER)) && ((total_line - (num_of_matched - prev_num_of_matched)> 0) || !NOOUTPUTZERO) ) {
  2970.                         if(FNAME && (NEW_FILE || !POST_FILTER)) {
  2971.                             if (agrep_finalfp != NULL)
  2972.                                 fprintf(agrep_finalfp, "%s: %d\n", CurrentFileName, total_line - (num_of_matched - prev_num_of_matched));
  2973.                             else {
  2974.                                 char s[32];
  2975.                                 int  outindex;
  2976.  
  2977.                                 sprintf(s, ": %d\n", total_line - (num_of_matched - prev_num_of_matched));
  2978.  
  2979.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2980.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  2981.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  2982.                                 }
  2983.                                 if (CurrentFileName[outindex] != '\0') {
  2984.                                     OUTPUT_OVERFLOW;
  2985.                                     close(fd);
  2986.                                     return -1;
  2987.                                 }
  2988.                                 agrep_outpointer += outindex;
  2989.  
  2990.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2991.                                         (s[outindex] != '\0'); outindex++) {
  2992.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2993.                                 }
  2994.                                 if (s[outindex] != '\0') {
  2995.                                     OUTPUT_OVERFLOW;
  2996.                                     close(fd);
  2997.                                     return -1;
  2998.                                 }
  2999.                                 agrep_outpointer += outindex;
  3000.                             }
  3001.                             NEW_FILE = OFF;
  3002.                         }
  3003.                         else if (!FNAME) {
  3004.                             if (agrep_finalfp != NULL)
  3005.                                 fprintf(agrep_finalfp, "%d\n", total_line - (num_of_matched - prev_num_of_matched));
  3006.                             else {
  3007.                                 char s[32];
  3008.                                 int  outindex;
  3009.  
  3010.                                 sprintf(s, "%d\n", total_line - (num_of_matched - prev_num_of_matched));
  3011.  
  3012.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3013.                                         (s[outindex] != '\0'); outindex++) {
  3014.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3015.                                 }
  3016.                                 if (s[outindex] != '\0') {
  3017.                                     OUTPUT_OVERFLOW;
  3018.                                     close(fd);
  3019.                                     return -1;
  3020.                                 }
  3021.                                 agrep_outpointer += outindex;
  3022.                             }
  3023.                         }
  3024.                     }
  3025.                     else if ( !(INVERSE && (PAT_FILE || PAT_BUFFER)) && (((num_of_matched - prev_num_of_matched) > 0) || !NOOUTPUTZERO) ) {
  3026.                         /* inverse is always 0 in glimpse, so we always come here */
  3027.                         if(FNAME && (NEW_FILE || !POST_FILTER)) {
  3028.                             if (agrep_finalfp != NULL)
  3029.                                 fprintf(agrep_finalfp, "%s: %d\n", CurrentFileName, (num_of_matched - prev_num_of_matched)); 
  3030.                             else {
  3031.                                 char s[32];
  3032.                                 int  outindex;
  3033.  
  3034.                                 sprintf(s, ": %d\n", (num_of_matched - prev_num_of_matched));
  3035.  
  3036.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3037.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  3038.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  3039.                                 }
  3040.                                 if (CurrentFileName[outindex] != '\0') {
  3041.                                     OUTPUT_OVERFLOW;
  3042.                                     close(fd);
  3043.                                     return -1;
  3044.                                 }
  3045.                                 agrep_outpointer += outindex;
  3046.  
  3047.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3048.                                         (s[outindex] != '\0'); outindex++) {
  3049.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3050.                                 }
  3051.                                 if (s[outindex] != '\0') {
  3052.                                     OUTPUT_OVERFLOW;
  3053.                                     close(fd);
  3054.                                     return -1;
  3055.                                 }
  3056.                                 agrep_outpointer += outindex;
  3057.                             }
  3058.                             NEW_FILE = OFF;
  3059.                         }
  3060.                         else if (!FNAME) {
  3061.                             if (agrep_finalfp != NULL)
  3062.                                 fprintf(agrep_finalfp, "%d\n", (num_of_matched - prev_num_of_matched));
  3063.                             else {
  3064.                                 char s[32];
  3065.                                 int  outindex;
  3066.  
  3067.                                 sprintf(s, "%d\n", (num_of_matched - prev_num_of_matched));
  3068.  
  3069.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3070.                                         (s[outindex] != '\0'); outindex++) {
  3071.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3072.                                 }
  3073.                                 if (s[outindex] != '\0') {
  3074.                                     OUTPUT_OVERFLOW;
  3075.                                     close(fd);
  3076.                                     return -1;
  3077.                                 }
  3078.                                 agrep_outpointer += outindex;
  3079.                             }
  3080.                         }
  3081.                     }
  3082.                 }  /* if COUNT */
  3083.                 if(FILEOUT && (num_of_matched - prev_num_of_matched)) {
  3084.                     if (-1 == file_out(file_list[i])) {
  3085.                         close(fd);
  3086.                         return -1;
  3087.                     }
  3088.                 }
  3089.             } /* else */
  3090.             if (glimpse_clientdied) {
  3091.                 close(fd);
  3092.                 return -1;
  3093.             }
  3094.             if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  3095.             if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  3096.                 ((LIMITTOTALFILE > 0) && (LIMITTOTALFILE <= files_matched))) {
  3097.                 close(fd);
  3098.                 break;    /* done */
  3099.             }
  3100.         }  /* for i < Numfiles */
  3101.  
  3102.         if(NOMATCH && BESTMATCH) {
  3103.             if(WORDBOUND || WHOLELINE || LINENUM || INVERSE) { 
  3104.                 SGREP = 0;    
  3105.                 if(-1 == preprocess(D_pattern, Pattern)) return -1;
  3106.                 strcpy(old_D_pat, D_pattern);
  3107.                 if((M = maskgen(Pattern, D)) == -1) return -1;
  3108.             }
  3109.             COUNT=ON; 
  3110.             D=1;
  3111.             while(D<M && D<=MaxError && (num_of_matched - prev_num_of_matched == 0)) {
  3112.                 for (i = 0; i < Numfiles; i++, close(fd)) {
  3113.                     prev_num_of_matched = num_of_matched;
  3114.                     CurrentByteOffset = 0;
  3115.                     if (PRINTFILENUMBER) sprintf(CurrentFileName, "%d", i);
  3116.                     else strcpy(CurrentFileName, file_list[i]);
  3117.                     NEW_FILE = ON;
  3118.                     if ((fd = open(Textfiles[i], O_RDONLY)) > 0) {
  3119.                         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  3120.                         else {
  3121.                             if(SGREP) ret = sgrep(OldPattern,strlen(OldPattern),fd,D, i);
  3122.                             else ret = bitap(old_D_pat,Pattern,fd,M,D);
  3123.                         }
  3124.                         if (ret <= -1) return -1;
  3125.                     }
  3126.                     if (glimpse_clientdied) {
  3127.                         close(fd);
  3128.                         return -1;
  3129.                     }
  3130.                     if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  3131.                     if ((((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  3132.                          ((LIMITTOTALFILE > 0) && (LIMITTOTALFILE <= files_matched))) &&
  3133.                         (num_of_matched > prev_num_of_matched)) {
  3134.                         close(fd);
  3135.                         break;
  3136.                     }
  3137.                 }  /* for i < Numfiles */
  3138.                 D++;
  3139.             } /* while */
  3140.  
  3141.             if(num_of_matched - prev_num_of_matched > 0) {
  3142.                 D--; 
  3143.                 errno = D;    /* #of errors if proper return */
  3144.                 COUNT = 0;
  3145.  
  3146.                 if(num_of_matched - prev_num_of_matched == 1) fprintf(stderr,"%s: 1 word matches ", Progname);
  3147.                 else fprintf(stderr,"%s: %d words match ", Progname, num_of_matched - prev_num_of_matched);
  3148.                 if(D==1) fprintf(stderr, "within 1 error");
  3149.                 else fprintf(stderr, "within %d errors", D);
  3150.  
  3151.                 fflush(stderr);
  3152.  
  3153.                 if(NOPROMPT) fprintf(stderr, "\n");
  3154.                 else {
  3155.                     if(num_of_matched - prev_num_of_matched == 1) fprintf(stderr,"; search for it? (y/n)");
  3156.                     else fprintf(stderr,"; search for them? (y/n)");
  3157.                     c[0] = 'y';
  3158.                     if (!glimpse_isserver && (fgets(c, 4, stdin) == NULL)) goto CONT;
  3159.                     if(c[0] != 'y') goto CONT;
  3160.                 }
  3161.  
  3162.                 for (i = 0; i < Numfiles; i++, close(fd)) {
  3163.                     prev_num_of_matched = num_of_matched;
  3164.                     CurrentByteOffset = 0;
  3165.                     if (PRINTFILENUMBER) sprintf(CurrentFileName, "%d", i);
  3166.                     else strcpy(CurrentFileName, file_list[i]);
  3167.                     NEW_FILE = ON;
  3168.                     if ((fd = open(Textfiles[i], O_RDONLY)) > 0) {
  3169.                         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  3170.                         else {
  3171.                             if(SGREP) ret = sgrep(OldPattern,strlen(OldPattern),fd,D, i);
  3172.                             else ret = bitap(old_D_pat,Pattern,fd,M,D);
  3173.                         }
  3174.                         if (ret <= -1) {
  3175.                             close(fd);
  3176.                             return -1;
  3177.                         }
  3178.                     }
  3179.                     if (glimpse_clientdied) {
  3180.                         close(fd);
  3181.                         return -1;
  3182.                     }
  3183.                     if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  3184.                     if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  3185.                         ((LIMITTOTALFILE > 0) && (LIMITTOTALFILE <= files_matched))) {
  3186.                         close(fd);
  3187.                         break;    /* done */
  3188.                     }
  3189.                 }  /* for i < Numfiles */
  3190.                 NOMATCH = 0;
  3191.             }
  3192.         }
  3193.     }
  3194. CONT:
  3195.     if(EATFIRST) {
  3196.         if (agrep_finalfp != NULL) fprintf(agrep_finalfp, "\n");
  3197.         else if (agrep_outpointer >= agrep_outlen) {
  3198.             OUTPUT_OVERFLOW;
  3199.             return -1;
  3200.         }
  3201.         else agrep_outbuffer[agrep_outpointer++] = '\n';
  3202.         EATFIRST = OFF;
  3203.     }
  3204.     if(num_of_matched - prev_num_of_matched > 0) NOMATCH = OFF;
  3205.     /* if(NOMATCH) return(0); */
  3206.     /*printf("exec=%d\n", num_of_matched);*/
  3207.     return(num_of_matched);
  3208.  
  3209. } /* end of exec() */
  3210.  
  3211.  
  3212. /* Just output the contents of the file fname onto the std output */
  3213. int
  3214. file_out(fname)
  3215. char *fname;
  3216. {
  3217.     int num_read;
  3218.     int fd;
  3219.     int i, len;
  3220.     CHAR buf[SIZE+2];
  3221.     if(FNAME) {
  3222.         len = strlen(fname);
  3223.         if (agrep_finalfp != NULL) {
  3224.             fputc('\n', agrep_finalfp);
  3225.             for(i=0; i< len; i++) fputc(':', agrep_finalfp);
  3226.             fputc('\n', agrep_finalfp);
  3227.             fprintf(agrep_finalfp, "%s\n", fname);
  3228.             for(i=0; i< len; i++) fputc(':', agrep_finalfp);
  3229.             fputc('\n', agrep_finalfp);
  3230.             fflush(agrep_finalfp);
  3231.         }
  3232.         else {
  3233.             if (1+len+1+len+1+len+1+agrep_outpointer >= agrep_outlen) {
  3234.                 OUTPUT_OVERFLOW;
  3235.                 return -1;
  3236.             }
  3237.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3238.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = ':';
  3239.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3240.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = fname[i];
  3241.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3242.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = ':';
  3243.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3244.         }
  3245.     }
  3246.     fd = open(fname, O_RDONLY);
  3247.     if (agrep_finalfp != NULL) {
  3248.         while((num_read = fill_buf(fd, buf, SIZE)) > 0) 
  3249.             write(1, buf, num_read);
  3250.         if (glimpse_clientdied) {
  3251.             close(fd);
  3252.             return -1;
  3253.         }
  3254.     }
  3255.     else {
  3256.         if ((num_read = fill_buf(fd, agrep_outbuffer + agrep_outpointer, agrep_outlen - agrep_outpointer)) > 0)
  3257.             agrep_outpointer += num_read;
  3258.     }
  3259.     close(fd);
  3260.     return 0;
  3261. }
  3262.  
  3263. int
  3264. output(buffer, i1, i2, j)  
  3265. register CHAR *buffer; 
  3266. int i1, i2, j;
  3267. {
  3268.     int PRINTED = 0;
  3269.     register CHAR *bp, *outend;
  3270.     if(i1 > i2) return 0;
  3271.     num_of_matched++;
  3272.     if(COUNT)  return 0;
  3273.     if(SILENT) return 0;
  3274.     if(OUTTAIL || (!DELIMITER && (D_length == 1) && (D_pattern[0] == '\n')) ) {
  3275.         if (j>1) i1 = i1 + D_length;
  3276.         i2 = i2 + D_length;
  3277.     }
  3278.     if(DELIMITER) j = j+1;
  3279.     if(FIRSTOUTPUT) {
  3280.         if (buffer[i1] == '\n')  {
  3281.             i1++;
  3282.             EATFIRST = ON;
  3283.         }
  3284.         FIRSTOUTPUT = 0;
  3285.     }
  3286.     if(TRUNCATE) {
  3287.         fprintf(stderr, "WARNING!  some lines have been truncated in output record #%d\n", num_of_matched-1);
  3288.     }
  3289.  
  3290.     /* Why do we have to do this? */
  3291.     while ((buffer[i1] == '\n') && (i1 <= i2)) {
  3292.         if (agrep_finalfp != NULL) fprintf(agrep_finalfp, "\n");
  3293.         else {
  3294.             if (agrep_outpointer < agrep_outlen)
  3295.                 agrep_outbuffer[agrep_outpointer ++] = '\n';
  3296.             else {
  3297.                 OUTPUT_OVERFLOW;
  3298.                 return -1;
  3299.             }
  3300.         }
  3301.         i1++;
  3302.     }
  3303.  
  3304.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  3305.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  3306.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  3307.         if (agrep_finalfp != NULL)
  3308.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  3309.         else {
  3310.             int outindex;
  3311.             if (prevstring[0] != '\0') {
  3312.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  3313.                     OUTPUT_OVERFLOW;
  3314.                     return -1;
  3315.                 }
  3316.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  3317.             }
  3318.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3319.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  3320.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  3321.             }
  3322.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  3323.                 OUTPUT_OVERFLOW;
  3324.                 return -1;
  3325.             }
  3326.             else {
  3327.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  3328.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  3329.             }
  3330.             agrep_outpointer += outindex;
  3331.         }
  3332.         NEW_FILE = OFF;
  3333.         PRINTED = 1;
  3334.     }
  3335.     if(LINENUM) {
  3336.         if (agrep_finalfp != NULL)
  3337.             fprintf(agrep_finalfp, "%d: ", j-1); 
  3338.         else {
  3339.             char s[32];
  3340.             int  outindex;
  3341.  
  3342.             sprintf(s, "%d: ", j-1);
  3343.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3344.                     (s[outindex] != '\0'); outindex++) {
  3345.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3346.             }
  3347.             if (s[outindex] != '\0') {
  3348.                 OUTPUT_OVERFLOW;
  3349.                 return -1;
  3350.             }
  3351.             agrep_outpointer += outindex;
  3352.         }
  3353.         PRINTED = 1;
  3354.     }
  3355.     if(BYTECOUNT) {
  3356.         if (agrep_finalfp != NULL)
  3357.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset-1);
  3358.         else {
  3359.             char s[32];
  3360.             int  outindex;
  3361.             sprintf(s, "%d= ", CurrentByteOffset-1);
  3362.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3363.                     (s[outindex] != '\0'); outindex++) {
  3364.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3365.             }
  3366.             if (s[outindex] != '\0') {
  3367.                 OUTPUT_OVERFLOW;
  3368.                 return -1;
  3369.             }
  3370.             agrep_outpointer += outindex;
  3371.         }
  3372.         PRINTED = 1;
  3373.     }
  3374.  
  3375.     bp = buffer + i1;
  3376.     outend = buffer + i2;
  3377.  
  3378.     if (PRINTOFFSET) {
  3379.         if (agrep_finalfp != NULL)
  3380.             fprintf(agrep_finalfp, "@%d{%d}\n", CurrentByteOffset - (i2-i1), i2-i1);
  3381.         else {
  3382.             char s[32];
  3383.             int outindex;
  3384.             sprintf(s, "@%d{%d}\n", CurrentByteOffset - (i2-i1), i2-i1);
  3385.             for (outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3386.                      (s[outindex] != '\0'); outindex ++) {
  3387.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3388.             }
  3389.             if (s[outindex] != '\0') {
  3390.                 OUTPUT_OVERFLOW;
  3391.                 return -1;
  3392.             }
  3393.             agrep_outpointer += outindex;
  3394.         }
  3395.         PRINTED = 1;
  3396.     }
  3397.  
  3398.     if (PRINTRECORD) {
  3399.     if (agrep_finalfp != NULL)
  3400.         while(bp <= outend) fputc(*bp++, agrep_finalfp);
  3401.     else {
  3402.         if (outend - bp + 1 + agrep_outpointer >= agrep_outlen) {
  3403.             OUTPUT_OVERFLOW;
  3404.             return -1;
  3405.         }
  3406.         while(bp <= outend) agrep_outbuffer[agrep_outpointer ++] = *bp++;
  3407.     }
  3408.     }
  3409.     else if (PRINTED) {
  3410.         if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);
  3411.         else agrep_outbuffer[agrep_outpointer ++] = '\n';
  3412.         PRINTED = 0;
  3413.     }
  3414.     return 0;
  3415. }
  3416.  
  3417. int
  3418. agrep_usage()
  3419. {
  3420.     if (glimpse_call) return -1;
  3421.     fprintf(stderr, "usage: %s [-#abcdehiklnoprstvwxyBDGIMSV] [-f patternfile] [-H dir] pattern [files]\n", Progname); 
  3422.     fprintf(stderr, "\n");    
  3423.     fprintf(stderr, "summary of frequently used options:\n");
  3424.     fprintf(stderr, "(For a more detailed listing see 'man agrep'.)\n");
  3425.     fprintf(stderr, "-#: find matches with at most # errors\n");
  3426.     fprintf(stderr, "-c: output the number of matched records\n");
  3427.     fprintf(stderr, "-d: define record delimiter\n");
  3428.     fprintf(stderr, "-h: do not output file names\n");
  3429.     fprintf(stderr, "-i: case-insensitive search, e.g., 'a' = 'A'\n");
  3430.     fprintf(stderr, "-l: output the names of files that contain a match\n");
  3431.     fprintf(stderr, "-n: output record prefixed by record number\n");
  3432.     fprintf(stderr, "-v: output those records that have no matches\n");
  3433.     fprintf(stderr, "-w: pattern has to match as a word, e.g., 'win' will not match 'wind'\n");
  3434.     fprintf(stderr, "-B: best match mode. find the closest matches to the pattern\n"); 
  3435.     fprintf(stderr, "-G: output the files that contain a match\n");
  3436.     fprintf(stderr, "-H 'dir': the cast-dictionary is located in directory 'dir'\n");
  3437.     fprintf(stderr, "\n");    
  3438.  
  3439.     if (!EXITONERROR) {
  3440.         errno = AGREP_ERROR;
  3441.         return -1;
  3442.     }
  3443.     else exit(2);
  3444. }
  3445.